diff --git a/.gitattributes b/.gitattributes
index 6299ca5544b0d5b3f413aa864c3bafa226c14fcf..d31e59a6accf5c4d1cc0d33da112ca22836aba7a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -664,3 +664,4 @@ benchmark/iGeo/2017iGeo_FWE-1_TASK-1С.pdf filter=lfs diff=lfs merge=lfs -text
 benchmark/iGeo/2017iGeo_FWE-2.pdf filter=lfs diff=lfs merge=lfs -text
 benchmark/iGeo/2017iGeo_FWE_Resource-booklet.pdf filter=lfs diff=lfs merge=lfs -text
 benchmark/iGeo/2017iGeo_WRT_MARKING-SCHEME.pdf filter=lfs diff=lfs merge=lfs -text
+benchmark/LiveCodeBench/test.jsonl filter=lfs diff=lfs merge=lfs -text
diff --git a/benchmark/LiveCodeBench/test.jsonl b/benchmark/LiveCodeBench/test.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..87e6967e48b790bbff689d0686510ec02a118390
--- /dev/null
+++ b/benchmark/LiveCodeBench/test.jsonl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bd02b38beb48e8c46b5b9987095d999ff38cd8efc255ea5d58974317c48f63f
+size 1252609773
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/autocompletion.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/autocompletion.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a04199e6dc06f71c57a0bb14c175476a8410b42
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/autocompletion.py
@@ -0,0 +1,152 @@
+"""Logic that powers autocompletion installed by ``pip completion``.
+"""
+
+import optparse
+import os
+import sys
+
+from pip._internal.cli.main_parser import create_main_parser
+from pip._internal.commands import commands_dict, get_summaries
+from pip._internal.utils.misc import get_installed_distributions
+
+
+def autocomplete():
+    """Entry Point for completion of main and subcommand options.
+    """
+    # Don't complete if user hasn't sourced bash_completion file.
+    if 'PIP_AUTO_COMPLETE' not in os.environ:
+        return
+    cwords = os.environ['COMP_WORDS'].split()[1:]
+    cword = int(os.environ['COMP_CWORD'])
+    try:
+        current = cwords[cword - 1]
+    except IndexError:
+        current = ''
+
+    subcommands = [cmd for cmd, summary in get_summaries()]
+    options = []
+    # subcommand
+    try:
+        subcommand_name = [w for w in cwords if w in subcommands][0]
+    except IndexError:
+        subcommand_name = None
+
+    parser = create_main_parser()
+    # subcommand options
+    if subcommand_name:
+        # special case: 'help' subcommand has no options
+        if subcommand_name == 'help':
+            sys.exit(1)
+        # special case: list locally installed dists for show and uninstall
+        should_list_installed = (
+            subcommand_name in ['show', 'uninstall'] and
+            not current.startswith('-')
+        )
+        if should_list_installed:
+            installed = []
+            lc = current.lower()
+            for dist in get_installed_distributions(local_only=True):
+                if dist.key.startswith(lc) and dist.key not in cwords[1:]:
+                    installed.append(dist.key)
+            # if there are no dists installed, fall back to option completion
+            if installed:
+                for dist in installed:
+                    print(dist)
+                sys.exit(1)
+
+        subcommand = commands_dict[subcommand_name]()
+
+        for opt in subcommand.parser.option_list_all:
+            if opt.help != optparse.SUPPRESS_HELP:
+                for opt_str in opt._long_opts + opt._short_opts:
+                    options.append((opt_str, opt.nargs))
+
+        # filter out previously specified options from available options
+        prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
+        options = [(x, v) for (x, v) in options if x not in prev_opts]
+        # filter options by current input
+        options = [(k, v) for k, v in options if k.startswith(current)]
+        # get completion type given cwords and available subcommand options
+        completion_type = get_path_completion_type(
+            cwords, cword, subcommand.parser.option_list_all,
+        )
+        # get completion files and directories if ``completion_type`` is
+        # ``<file>``, ``<dir>`` or ``<path>``
+        if completion_type:
+            options = auto_complete_paths(current, completion_type)
+            options = ((opt, 0) for opt in options)
+        for option in options:
+            opt_label = option[0]
+            # append '=' to options which require args
+            if option[1] and option[0][:2] == "--":
+                opt_label += '='
+            print(opt_label)
+    else:
+        # show main parser options only when necessary
+
+        opts = [i.option_list for i in parser.option_groups]
+        opts.append(parser.option_list)
+        opts = (o for it in opts for o in it)
+        if current.startswith('-'):
+            for opt in opts:
+                if opt.help != optparse.SUPPRESS_HELP:
+                    subcommands += opt._long_opts + opt._short_opts
+        else:
+            # get completion type given cwords and all available options
+            completion_type = get_path_completion_type(cwords, cword, opts)
+            if completion_type:
+                subcommands = auto_complete_paths(current, completion_type)
+
+        print(' '.join([x for x in subcommands if x.startswith(current)]))
+    sys.exit(1)
+
+
+def get_path_completion_type(cwords, cword, opts):
+    """Get the type of path completion (``file``, ``dir``, ``path`` or None)
+
+    :param cwords: same as the environmental variable ``COMP_WORDS``
+    :param cword: same as the environmental variable ``COMP_CWORD``
+    :param opts: The available options to check
+    :return: path completion type (``file``, ``dir``, ``path`` or None)
+    """
+    if cword < 2 or not cwords[cword - 2].startswith('-'):
+        return
+    for opt in opts:
+        if opt.help == optparse.SUPPRESS_HELP:
+            continue
+        for o in str(opt).split('/'):
+            if cwords[cword - 2].split('=')[0] == o:
+                if not opt.metavar or any(
+                        x in ('path', 'file', 'dir')
+                        for x in opt.metavar.split('/')):
+                    return opt.metavar
+
+
+def auto_complete_paths(current, completion_type):
+    """If ``completion_type`` is ``file`` or ``path``, list all regular files
+    and directories starting with ``current``; otherwise only list directories
+    starting with ``current``.
+
+    :param current: The word to be completed
+    :param completion_type: path completion type(`file`, `path` or `dir`)i
+    :return: A generator of regular files and/or directories
+    """
+    directory, filename = os.path.split(current)
+    current_path = os.path.abspath(directory)
+    # Don't complete paths if they can't be accessed
+    if not os.access(current_path, os.R_OK):
+        return
+    filename = os.path.normcase(filename)
+    # list all files that start with ``filename``
+    file_list = (x for x in os.listdir(current_path)
+                 if os.path.normcase(x).startswith(filename))
+    for f in file_list:
+        opt = os.path.join(current_path, f)
+        comp_file = os.path.normcase(os.path.join(directory, f))
+        # complete regular files when there is not ``<dir>`` after option
+        # complete directories when there is ``<file>``, ``<path>`` or
+        # ``<dir>``after option
+        if completion_type != 'dir' and os.path.isfile(opt):
+            yield comp_file
+        elif os.path.isdir(opt):
+            yield os.path.join(comp_file, '')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/base_command.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/base_command.py
new file mode 100644
index 0000000000000000000000000000000000000000..90830be4a5649525c96847f79d413ac57f4908f1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/base_command.py
@@ -0,0 +1,346 @@
+"""Base Command class, and related routines"""
+from __future__ import absolute_import, print_function
+
+import logging
+import logging.config
+import optparse
+import os
+import platform
+import sys
+import traceback
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_search_scope
+from pip._internal.cli.parser import (
+    ConfigOptionParser, UpdatingDefaultsHelpFormatter,
+)
+from pip._internal.cli.status_codes import (
+    ERROR, PREVIOUS_BUILD_DIR_ERROR, SUCCESS, UNKNOWN_ERROR,
+    VIRTUALENV_NOT_FOUND,
+)
+from pip._internal.download import PipSession
+from pip._internal.exceptions import (
+    BadCommand, CommandError, InstallationError, PreviousBuildDirError,
+    UninstallationError,
+)
+from pip._internal.index import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.models.target_python import TargetPython
+from pip._internal.req.constructors import (
+    install_req_from_editable, install_req_from_line,
+)
+from pip._internal.req.req_file import parse_requirements
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.logging import BrokenStdoutLoggingError, setup_logging
+from pip._internal.utils.misc import get_prog, normalize_path
+from pip._internal.utils.outdated import pip_version_check
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+if MYPY_CHECK_RUNNING:
+    from typing import Optional, List, Tuple, Any
+    from optparse import Values
+    from pip._internal.cache import WheelCache
+    from pip._internal.req.req_set import RequirementSet
+
+__all__ = ['Command']
+
+logger = logging.getLogger(__name__)
+
+
+class Command(object):
+    name = None  # type: Optional[str]
+    usage = None  # type: Optional[str]
+    ignore_require_venv = False  # type: bool
+
+    def __init__(self, isolated=False):
+        # type: (bool) -> None
+        parser_kw = {
+            'usage': self.usage,
+            'prog': '%s %s' % (get_prog(), self.name),
+            'formatter': UpdatingDefaultsHelpFormatter(),
+            'add_help_option': False,
+            'name': self.name,
+            'description': self.__doc__,
+            'isolated': isolated,
+        }
+
+        self.parser = ConfigOptionParser(**parser_kw)
+
+        # Commands should add options to this option group
+        optgroup_name = '%s Options' % self.name.capitalize()
+        self.cmd_opts = optparse.OptionGroup(self.parser, optgroup_name)
+
+        # Add the general options
+        gen_opts = cmdoptions.make_option_group(
+            cmdoptions.general_group,
+            self.parser,
+        )
+        self.parser.add_option_group(gen_opts)
+
+    def run(self, options, args):
+        # type: (Values, List[Any]) -> Any
+        raise NotImplementedError
+
+    @classmethod
+    def _get_index_urls(cls, options):
+        """Return a list of index urls from user-provided options."""
+        index_urls = []
+        if not getattr(options, "no_index", False):
+            url = getattr(options, "index_url", None)
+            if url:
+                index_urls.append(url)
+        urls = getattr(options, "extra_index_urls", None)
+        if urls:
+            index_urls.extend(urls)
+        # Return None rather than an empty list
+        return index_urls or None
+
+    def _build_session(self, options, retries=None, timeout=None):
+        # type: (Values, Optional[int], Optional[int]) -> PipSession
+        session = PipSession(
+            cache=(
+                normalize_path(os.path.join(options.cache_dir, "http"))
+                if options.cache_dir else None
+            ),
+            retries=retries if retries is not None else options.retries,
+            insecure_hosts=options.trusted_hosts,
+            index_urls=self._get_index_urls(options),
+        )
+
+        # Handle custom ca-bundles from the user
+        if options.cert:
+            session.verify = options.cert
+
+        # Handle SSL client certificate
+        if options.client_cert:
+            session.cert = options.client_cert
+
+        # Handle timeouts
+        if options.timeout or timeout:
+            session.timeout = (
+                timeout if timeout is not None else options.timeout
+            )
+
+        # Handle configured proxies
+        if options.proxy:
+            session.proxies = {
+                "http": options.proxy,
+                "https": options.proxy,
+            }
+
+        # Determine if we can prompt the user for authentication or not
+        session.auth.prompting = not options.no_input
+
+        return session
+
+    def parse_args(self, args):
+        # type: (List[str]) -> Tuple
+        # factored out for testability
+        return self.parser.parse_args(args)
+
+    def main(self, args):
+        # type: (List[str]) -> int
+        options, args = self.parse_args(args)
+
+        # Set verbosity so that it can be used elsewhere.
+        self.verbosity = options.verbose - options.quiet
+
+        level_number = setup_logging(
+            verbosity=self.verbosity,
+            no_color=options.no_color,
+            user_log_file=options.log,
+        )
+
+        if sys.version_info[:2] == (2, 7):
+            message = (
+                "A future version of pip will drop support for Python 2.7. "
+                "More details about Python 2 support in pip, can be found at "
+                "https://pip.pypa.io/en/latest/development/release-process/#python-2-support"  # noqa
+            )
+            if platform.python_implementation() == "CPython":
+                message = (
+                    "Python 2.7 will reach the end of its life on January "
+                    "1st, 2020. Please upgrade your Python as Python 2.7 "
+                    "won't be maintained after that date. "
+                ) + message
+            deprecated(message, replacement=None, gone_in=None)
+
+        # TODO: Try to get these passing down from the command?
+        #       without resorting to os.environ to hold these.
+        #       This also affects isolated builds and it should.
+
+        if options.no_input:
+            os.environ['PIP_NO_INPUT'] = '1'
+
+        if options.exists_action:
+            os.environ['PIP_EXISTS_ACTION'] = ' '.join(options.exists_action)
+
+        if options.require_venv and not self.ignore_require_venv:
+            # If a venv is required check if it can really be found
+            if not running_under_virtualenv():
+                logger.critical(
+                    'Could not find an activated virtualenv (required).'
+                )
+                sys.exit(VIRTUALENV_NOT_FOUND)
+
+        try:
+            status = self.run(options, args)
+            # FIXME: all commands should return an exit status
+            # and when it is done, isinstance is not needed anymore
+            if isinstance(status, int):
+                return status
+        except PreviousBuildDirError as exc:
+            logger.critical(str(exc))
+            logger.debug('Exception information:', exc_info=True)
+
+            return PREVIOUS_BUILD_DIR_ERROR
+        except (InstallationError, UninstallationError, BadCommand) as exc:
+            logger.critical(str(exc))
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except CommandError as exc:
+            logger.critical('%s', exc)
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except BrokenStdoutLoggingError:
+            # Bypass our logger and write any remaining messages to stderr
+            # because stdout no longer works.
+            print('ERROR: Pipe to stdout was broken', file=sys.stderr)
+            if level_number <= logging.DEBUG:
+                traceback.print_exc(file=sys.stderr)
+
+            return ERROR
+        except KeyboardInterrupt:
+            logger.critical('Operation cancelled by user')
+            logger.debug('Exception information:', exc_info=True)
+
+            return ERROR
+        except BaseException:
+            logger.critical('Exception:', exc_info=True)
+
+            return UNKNOWN_ERROR
+        finally:
+            allow_version_check = (
+                # Does this command have the index_group options?
+                hasattr(options, "no_index") and
+                # Is this command allowed to perform this check?
+                not (options.disable_pip_version_check or options.no_index)
+            )
+            # Check if we're using the latest version of pip available
+            if allow_version_check:
+                session = self._build_session(
+                    options,
+                    retries=0,
+                    timeout=min(5, options.timeout)
+                )
+                with session:
+                    pip_version_check(session, options)
+
+            # Shutdown the logging module
+            logging.shutdown()
+
+        return SUCCESS
+
+
+class RequirementCommand(Command):
+
+    @staticmethod
+    def populate_requirement_set(requirement_set,  # type: RequirementSet
+                                 args,             # type: List[str]
+                                 options,          # type: Values
+                                 finder,           # type: PackageFinder
+                                 session,          # type: PipSession
+                                 name,             # type: str
+                                 wheel_cache       # type: Optional[WheelCache]
+                                 ):
+        # type: (...) -> None
+        """
+        Marshal cmd line args into a requirement set.
+        """
+        # NOTE: As a side-effect, options.require_hashes and
+        #       requirement_set.require_hashes may be updated
+
+        for filename in options.constraints:
+            for req_to_add in parse_requirements(
+                    filename,
+                    constraint=True, finder=finder, options=options,
+                    session=session, wheel_cache=wheel_cache):
+                req_to_add.is_direct = True
+                requirement_set.add_requirement(req_to_add)
+
+        for req in args:
+            req_to_add = install_req_from_line(
+                req, None, isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+                wheel_cache=wheel_cache
+            )
+            req_to_add.is_direct = True
+            requirement_set.add_requirement(req_to_add)
+
+        for req in options.editables:
+            req_to_add = install_req_from_editable(
+                req,
+                isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+                wheel_cache=wheel_cache
+            )
+            req_to_add.is_direct = True
+            requirement_set.add_requirement(req_to_add)
+
+        for filename in options.requirements:
+            for req_to_add in parse_requirements(
+                    filename,
+                    finder=finder, options=options, session=session,
+                    wheel_cache=wheel_cache,
+                    use_pep517=options.use_pep517):
+                req_to_add.is_direct = True
+                requirement_set.add_requirement(req_to_add)
+        # If --require-hashes was a line in a requirements file, tell
+        # RequirementSet about it:
+        requirement_set.require_hashes = options.require_hashes
+
+        if not (args or options.editables or options.requirements):
+            opts = {'name': name}
+            if options.find_links:
+                raise CommandError(
+                    'You must give at least one requirement to %(name)s '
+                    '(maybe you meant "pip %(name)s %(links)s"?)' %
+                    dict(opts, links=' '.join(options.find_links)))
+            else:
+                raise CommandError(
+                    'You must give at least one requirement to %(name)s '
+                    '(see "pip help %(name)s")' % opts)
+
+    def _build_package_finder(
+        self,
+        options,               # type: Values
+        session,               # type: PipSession
+        target_python=None,    # type: Optional[TargetPython]
+        ignore_requires_python=None,  # type: Optional[bool]
+    ):
+        # type: (...) -> PackageFinder
+        """
+        Create a package finder appropriate to this requirement command.
+
+        :param ignore_requires_python: Whether to ignore incompatible
+            "Requires-Python" values in links. Defaults to False.
+        """
+        search_scope = make_search_scope(options)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=True,
+            format_control=options.format_control,
+            allow_all_prereleases=options.pre,
+            prefer_binary=options.prefer_binary,
+            ignore_requires_python=ignore_requires_python,
+        )
+
+        return PackageFinder.create(
+            search_scope=search_scope,
+            selection_prefs=selection_prefs,
+            trusted_hosts=options.trusted_hosts,
+            session=session,
+            target_python=target_python,
+        )
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/cmdoptions.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/cmdoptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5c6c22dcfd72ff6eb250b9123341a803853dc4b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cli/cmdoptions.py
@@ -0,0 +1,931 @@
+"""
+shared options and groups
+
+The principle here is to define options once, but *not* instantiate them
+globally. One reason being that options with action='append' can carry state
+between parses. pip parses general options twice internally, and shouldn't
+pass on state. To be consistent, all options will follow this design.
+
+"""
+from __future__ import absolute_import
+
+import logging
+import textwrap
+import warnings
+from distutils.util import strtobool
+from functools import partial
+from optparse import SUPPRESS_HELP, Option, OptionGroup
+from textwrap import dedent
+
+from pip._internal.exceptions import CommandError
+from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
+from pip._internal.models.format_control import FormatControl
+from pip._internal.models.index import PyPI
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.models.target_python import TargetPython
+from pip._internal.utils.hashes import STRONG_HASHES
+from pip._internal.utils.misc import redact_password_from_url
+from pip._internal.utils.typing import MYPY_CHECK_RUNNING
+from pip._internal.utils.ui import BAR_TYPES
+
+if MYPY_CHECK_RUNNING:
+    from typing import Any, Callable, Dict, Optional, Tuple
+    from optparse import OptionParser, Values
+    from pip._internal.cli.parser import ConfigOptionParser
+
+logger = logging.getLogger(__name__)
+
+
+def raise_option_error(parser, option, msg):
+    """
+    Raise an option parsing error using parser.error().
+
+    Args:
+      parser: an OptionParser instance.
+      option: an Option instance.
+      msg: the error text.
+    """
+    msg = '{} error: {}'.format(option, msg)
+    msg = textwrap.fill(' '.join(msg.split()))
+    parser.error(msg)
+
+
+def make_option_group(group, parser):
+    # type: (Dict[str, Any], ConfigOptionParser) -> OptionGroup
+    """
+    Return an OptionGroup object
+    group  -- assumed to be dict with 'name' and 'options' keys
+    parser -- an optparse Parser
+    """
+    option_group = OptionGroup(parser, group['name'])
+    for option in group['options']:
+        option_group.add_option(option())
+    return option_group
+
+
+def check_install_build_global(options, check_options=None):
+    # type: (Values, Optional[Values]) -> None
+    """Disable wheels if per-setup.py call options are set.
+
+    :param options: The OptionParser options to update.
+    :param check_options: The options to check, if not supplied defaults to
+        options.
+    """
+    if check_options is None:
+        check_options = options
+
+    def getname(n):
+        return getattr(check_options, n, None)
+    names = ["build_options", "global_options", "install_options"]
+    if any(map(getname, names)):
+        control = options.format_control
+        control.disallow_binaries()
+        warnings.warn(
+            'Disabling all use of wheels due to the use of --build-options '
+            '/ --global-options / --install-options.', stacklevel=2,
+        )
+
+
+def check_dist_restriction(options, check_target=False):
+    # type: (Values, bool) -> None
+    """Function for determining if custom platform options are allowed.
+
+    :param options: The OptionParser options.
+    :param check_target: Whether or not to check if --target is being used.
+    """
+    dist_restriction_set = any([
+        options.python_version,
+        options.platform,
+        options.abi,
+        options.implementation,
+    ])
+
+    binary_only = FormatControl(set(), {':all:'})
+    sdist_dependencies_allowed = (
+        options.format_control != binary_only and
+        not options.ignore_dependencies
+    )
+
+    # Installations or downloads using dist restrictions must not combine
+    # source distributions and dist-specific wheels, as they are not
+    # guaranteed to be locally compatible.
+    if dist_restriction_set and sdist_dependencies_allowed:
+        raise CommandError(
+            "When restricting platform and interpreter constraints using "
+            "--python-version, --platform, --abi, or --implementation, "
+            "either --no-deps must be set, or --only-binary=:all: must be "
+            "set and --no-binary must not be set (or must be set to "
+            ":none:)."
+        )
+
+    if check_target:
+        if dist_restriction_set and not options.target_dir:
+            raise CommandError(
+                "Can not use any platform or abi specific options unless "
+                "installing via '--target'"
+            )
+
+
+###########
+# options #
+###########
+
+help_ = partial(
+    Option,
+    '-h', '--help',
+    dest='help',
+    action='help',
+    help='Show help.',
+)  # type: Callable[..., Option]
+
+isolated_mode = partial(
+    Option,
+    "--isolated",
+    dest="isolated_mode",
+    action="store_true",
+    default=False,
+    help=(
+        "Run pip in an isolated mode, ignoring environment variables and user "
+        "configuration."
+    ),
+)  # type: Callable[..., Option]
+
+require_virtualenv = partial(
+    Option,
+    # Run only if inside a virtualenv, bail if not.
+    '--require-virtualenv', '--require-venv',
+    dest='require_venv',
+    action='store_true',
+    default=False,
+    help=SUPPRESS_HELP
+)  # type: Callable[..., Option]
+
+verbose = partial(
+    Option,
+    '-v', '--verbose',
+    dest='verbose',
+    action='count',
+    default=0,
+    help='Give more output. Option is additive, and can be used up to 3 times.'
+)  # type: Callable[..., Option]
+
+no_color = partial(
+    Option,
+    '--no-color',
+    dest='no_color',
+    action='store_true',
+    default=False,
+    help="Suppress colored output",
+)  # type: Callable[..., Option]
+
+version = partial(
+    Option,
+    '-V', '--version',
+    dest='version',
+    action='store_true',
+    help='Show version and exit.',
+)  # type: Callable[..., Option]
+
+quiet = partial(
+    Option,
+    '-q', '--quiet',
+    dest='quiet',
+    action='count',
+    default=0,
+    help=(
+        'Give less output. Option is additive, and can be used up to 3'
+        ' times (corresponding to WARNING, ERROR, and CRITICAL logging'
+        ' levels).'
+    ),
+)  # type: Callable[..., Option]
+
+progress_bar = partial(
+    Option,
+    '--progress-bar',
+    dest='progress_bar',
+    type='choice',
+    choices=list(BAR_TYPES.keys()),
+    default='on',
+    help=(
+        'Specify type of progress to be displayed [' +
+        '|'.join(BAR_TYPES.keys()) + '] (default: %default)'
+    ),
+)  # type: Callable[..., Option]
+
+log = partial(
+    Option,
+    "--log", "--log-file", "--local-log",
+    dest="log",
+    metavar="path",
+    help="Path to a verbose appending log."
+)  # type: Callable[..., Option]
+
+no_input = partial(
+    Option,
+    # Don't ask for input
+    '--no-input',
+    dest='no_input',
+    action='store_true',
+    default=False,
+    help=SUPPRESS_HELP
+)  # type: Callable[..., Option]
+
+proxy = partial(
+    Option,
+    '--proxy',
+    dest='proxy',
+    type='str',
+    default='',
+    help="Specify a proxy in the form [user:passwd@]proxy.server:port."
+)  # type: Callable[..., Option]
+
+retries = partial(
+    Option,
+    '--retries',
+    dest='retries',
+    type='int',
+    default=5,
+    help="Maximum number of retries each connection should attempt "
+         "(default %default times).",
+)  # type: Callable[..., Option]
+
+timeout = partial(
+    Option,
+    '--timeout', '--default-timeout',
+    metavar='sec',
+    dest='timeout',
+    type='float',
+    default=15,
+    help='Set the socket timeout (default %default seconds).',
+)  # type: Callable[..., Option]
+
+skip_requirements_regex = partial(
+    Option,
+    # A regex to be used to skip requirements
+    '--skip-requirements-regex',
+    dest='skip_requirements_regex',
+    type='str',
+    default='',
+    help=SUPPRESS_HELP,
+)  # type: Callable[..., Option]
+
+
+def exists_action():
+    # type: () -> Option
+    return Option(
+        # Option when path already exist
+        '--exists-action',
+        dest='exists_action',
+        type='choice',
+        choices=['s', 'i', 'w', 'b', 'a'],
+        default=[],
+        action='append',
+        metavar='action',
+        help="Default action when a path already exists: "
+             "(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.",
+    )
+
+
+cert = partial(
+    Option,
+    '--cert',
+    dest='cert',
+    type='str',
+    metavar='path',
+    help="Path to alternate CA bundle.",
+)  # type: Callable[..., Option]
+
+client_cert = partial(
+    Option,
+    '--client-cert',
+    dest='client_cert',
+    type='str',
+    default=None,
+    metavar='path',
+    help="Path to SSL client certificate, a single file containing the "
+         "private key and the certificate in PEM format.",
+)  # type: Callable[..., Option]
+
+index_url = partial(
+    Option,
+    '-i', '--index-url', '--pypi-url',
+    dest='index_url',
+    metavar='URL',
+    default=PyPI.simple_url,
+    help="Base URL of the Python Package Index (default %default). "
+         "This should point to a repository compliant with PEP 503 "
+         "(the simple repository API) or a local directory laid out "
+         "in the same format.",
+)  # type: Callable[..., Option]
+
+
+def extra_index_url():
+    return Option(
+        '--extra-index-url',
+        dest='extra_index_urls',
+        metavar='URL',
+        action='append',
+        default=[],
+        help="Extra URLs of package indexes to use in addition to "
+             "--index-url. Should follow the same rules as "
+             "--index-url.",
+    )
+
+
+no_index = partial(
+    Option,
+    '--no-index',
+    dest='no_index',
+    action='store_true',
+    default=False,
+    help='Ignore package index (only looking at --find-links URLs instead).',
+)  # type: Callable[..., Option]
+
+
+def find_links():
+    # type: () -> Option
+    return Option(
+        '-f', '--find-links',
+        dest='find_links',
+        action='append',
+        default=[],
+        metavar='url',
+        help="If a url or path to an html file, then parse for links to "
+             "archives. If a local path or file:// url that's a directory, "
+             "then look for archives in the directory listing.",
+    )
+
+
+def make_search_scope(options, suppress_no_index=False):
+    # type: (Values, bool) -> SearchScope
+    """
+    :param suppress_no_index: Whether to ignore the --no-index option
+        when constructing the SearchScope object.
+    """
+    index_urls = [options.index_url] + options.extra_index_urls
+    if options.no_index and not suppress_no_index:
+        logger.debug(
+            'Ignoring indexes: %s',
+            ','.join(redact_password_from_url(url) for url in index_urls),
+        )
+        index_urls = []
+
+    # Make sure find_links is a list before passing to create().
+    find_links = options.find_links or []
+
+    search_scope = SearchScope.create(
+        find_links=find_links, index_urls=index_urls,
+    )
+
+    return search_scope
+
+
+def trusted_host():
+    # type: () -> Option
+    return Option(
+        "--trusted-host",
+        dest="trusted_hosts",
+        action="append",
+        metavar="HOSTNAME",
+        default=[],
+        help="Mark this host as trusted, even though it does not have valid "
+             "or any HTTPS.",
+    )
+
+
+def constraints():
+    # type: () -> Option
+    return Option(
+        '-c', '--constraint',
+        dest='constraints',
+        action='append',
+        default=[],
+        metavar='file',
+        help='Constrain versions using the given constraints file. '
+        'This option can be used multiple times.'
+    )
+
+
+def requirements():
+    # type: () -> Option
+    return Option(
+        '-r', '--requirement',
+        dest='requirements',
+        action='append',
+        default=[],
+        metavar='file',
+        help='Install from the given requirements file. '
+        'This option can be used multiple times.'
+    )
+
+
+def editable():
+    # type: () -> Option
+    return Option(
+        '-e', '--editable',
+        dest='editables',
+        action='append',
+        default=[],
+        metavar='path/url',
+        help=('Install a project in editable mode (i.e. setuptools '
+              '"develop mode") from a local project path or a VCS url.'),
+    )
+
+
+src = partial(
+    Option,
+    '--src', '--source', '--source-dir', '--source-directory',
+    dest='src_dir',
+    metavar='dir',
+    default=get_src_prefix(),
+    help='Directory to check out editable projects into. '
+    'The default in a virtualenv is "<venv path>/src". '
+    'The default for global installs is "<current dir>/src".'
+)  # type: Callable[..., Option]
+
+
+def _get_format_control(values, option):
+    # type: (Values, Option) -> Any
+    """Get a format_control object."""
+    return getattr(values, option.dest)
+
+
+def _handle_no_binary(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value, existing.no_binary, existing.only_binary,
+    )
+
+
+def _handle_only_binary(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value, existing.only_binary, existing.no_binary,
+    )
+
+
+def no_binary():
+    # type: () -> Option
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--no-binary", dest="format_control", action="callback",
+        callback=_handle_no_binary, type="str",
+        default=format_control,
+        help="Do not use binary packages. Can be supplied multiple times, and "
+             "each time adds to the existing value. Accepts either :all: to "
+             "disable all binary packages, :none: to empty the set, or one or "
+             "more package names with commas between them. Note that some "
+             "packages are tricky to compile and may fail to install when "
+             "this option is used on them.",
+    )
+
+
+def only_binary():
+    # type: () -> Option
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--only-binary", dest="format_control", action="callback",
+        callback=_handle_only_binary, type="str",
+        default=format_control,
+        help="Do not use source packages. Can be supplied multiple times, and "
+             "each time adds to the existing value. Accepts either :all: to "
+             "disable all source packages, :none: to empty the set, or one or "
+             "more package names with commas between them. Packages without "
+             "binary distributions will fail to install when this option is "
+             "used on them.",
+    )
+
+
+platform = partial(
+    Option,
+    '--platform',
+    dest='platform',
+    metavar='platform',
+    default=None,
+    help=("Only use wheels compatible with <platform>. "
+          "Defaults to the platform of the running system."),
+)  # type: Callable[..., Option]
+
+
+# This was made a separate function for unit-testing purposes.
+def _convert_python_version(value):
+    # type: (str) -> Tuple[Tuple[int, ...], Optional[str]]
+    """
+    Convert a version string like "3", "37", or "3.7.3" into a tuple of ints.
+
+    :return: A 2-tuple (version_info, error_msg), where `error_msg` is
+        non-None if and only if there was a parsing error.
+    """
+    if not value:
+        # The empty string is the same as not providing a value.
+        return (None, None)
+
+    parts = value.split('.')
+    if len(parts) > 3:
+        return ((), 'at most three version parts are allowed')
+
+    if len(parts) == 1:
+        # Then we are in the case of "3" or "37".
+        value = parts[0]
+        if len(value) > 1:
+            parts = [value[0], value[1:]]
+
+    try:
+        version_info = tuple(int(part) for part in parts)
+    except ValueError:
+        return ((), 'each version part must be an integer')
+
+    return (version_info, None)
+
+
+def _handle_python_version(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Handle a provided --python-version value.
+    """
+    version_info, error_msg = _convert_python_version(value)
+    if error_msg is not None:
+        msg = (
+            'invalid --python-version value: {!r}: {}'.format(
+                value, error_msg,
+            )
+        )
+        raise_option_error(parser, option=option, msg=msg)
+
+    parser.values.python_version = version_info
+
+
+python_version = partial(
+    Option,
+    '--python-version',
+    dest='python_version',
+    metavar='python_version',
+    action='callback',
+    callback=_handle_python_version, type='str',
+    default=None,
+    help=dedent("""\
+    The Python interpreter version to use for wheel and "Requires-Python"
+    compatibility checks. Defaults to a version derived from the running
+    interpreter. The version can be specified using up to three dot-separated
+    integers (e.g. "3" for 3.0.0, "3.7" for 3.7.0, or "3.7.3"). A major-minor
+    version can also be given as a string without dots (e.g. "37" for 3.7.0).
+    """),
+)  # type: Callable[..., Option]
+
+
+implementation = partial(
+    Option,
+    '--implementation',
+    dest='implementation',
+    metavar='implementation',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
+          " or 'ip'. If not specified, then the current "
+          "interpreter implementation is used.  Use 'py' to force "
+          "implementation-agnostic wheels."),
+)  # type: Callable[..., Option]
+
+
+abi = partial(
+    Option,
+    '--abi',
+    dest='abi',
+    metavar='abi',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "abi <abi>, e.g. 'pypy_41'.  If not specified, then the "
+          "current interpreter abi tag is used.  Generally "
+          "you will need to specify --implementation, "
+          "--platform, and --python-version when using "
+          "this option."),
+)  # type: Callable[..., Option]
+
+
+def add_target_python_options(cmd_opts):
+    # type: (OptionGroup) -> None
+    cmd_opts.add_option(platform())
+    cmd_opts.add_option(python_version())
+    cmd_opts.add_option(implementation())
+    cmd_opts.add_option(abi())
+
+
+def make_target_python(options):
+    # type: (Values) -> TargetPython
+    target_python = TargetPython(
+        platform=options.platform,
+        py_version_info=options.python_version,
+        abi=options.abi,
+        implementation=options.implementation,
+    )
+
+    return target_python
+
+
+def prefer_binary():
+    # type: () -> Option
+    return Option(
+        "--prefer-binary",
+        dest="prefer_binary",
+        action="store_true",
+        default=False,
+        help="Prefer older binary packages over newer source packages."
+    )
+
+
+cache_dir = partial(
+    Option,
+    "--cache-dir",
+    dest="cache_dir",
+    default=USER_CACHE_DIR,
+    metavar="dir",
+    help="Store the cache data in <dir>."
+)  # type: Callable[..., Option]
+
+
+def _handle_no_cache_dir(option, opt, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Process a value provided for the --no-cache-dir option.
+
+    This is an optparse.Option callback for the --no-cache-dir option.
+    """
+    # The value argument will be None if --no-cache-dir is passed via the
+    # command-line, since the option doesn't accept arguments.  However,
+    # the value can be non-None if the option is triggered e.g. by an
+    # environment variable, like PIP_NO_CACHE_DIR=true.
+    if value is not None:
+        # Then parse the string value to get argument error-checking.
+        try:
+            strtobool(value)
+        except ValueError as exc:
+            raise_option_error(parser, option=option, msg=str(exc))
+
+    # Originally, setting PIP_NO_CACHE_DIR to a value that strtobool()
+    # converted to 0 (like "false" or "no") caused cache_dir to be disabled
+    # rather than enabled (logic would say the latter).  Thus, we disable
+    # the cache directory not just on values that parse to True, but (for
+    # backwards compatibility reasons) also on values that parse to False.
+    # In other words, always set it to False if the option is provided in
+    # some (valid) form.
+    parser.values.cache_dir = False
+
+
+no_cache = partial(
+    Option,
+    "--no-cache-dir",
+    dest="cache_dir",
+    action="callback",
+    callback=_handle_no_cache_dir,
+    help="Disable the cache.",
+)  # type: Callable[..., Option]
+
+no_deps = partial(
+    Option,
+    '--no-deps', '--no-dependencies',
+    dest='ignore_dependencies',
+    action='store_true',
+    default=False,
+    help="Don't install package dependencies.",
+)  # type: Callable[..., Option]
+
+build_dir = partial(
+    Option,
+    '-b', '--build', '--build-dir', '--build-directory',
+    dest='build_dir',
+    metavar='dir',
+    help='Directory to unpack packages into and build in. Note that '
+         'an initial build still takes place in a temporary directory. '
+         'The location of temporary directories can be controlled by setting '
+         'the TMPDIR environment variable (TEMP on Windows) appropriately. '
+         'When passed, build directories are not cleaned in case of failures.'
+)  # type: Callable[..., Option]
+
+ignore_requires_python = partial(
+    Option,
+    '--ignore-requires-python',
+    dest='ignore_requires_python',
+    action='store_true',
+    help='Ignore the Requires-Python information.'
+)  # type: Callable[..., Option]
+
+no_build_isolation = partial(
+    Option,
+    '--no-build-isolation',
+    dest='build_isolation',
+    action='store_false',
+    default=True,
+    help='Disable isolation when building a modern source distribution. '
+         'Build dependencies specified by PEP 518 must be already installed '
+         'if this option is used.'
+)  # type: Callable[..., Option]
+
+
+def _handle_no_use_pep517(option, opt, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """
+    Process a value provided for the --no-use-pep517 option.
+
+    This is an optparse.Option callback for the no_use_pep517 option.
+    """
+    # Since --no-use-pep517 doesn't accept arguments, the value argument
+    # will be None if --no-use-pep517 is passed via the command-line.
+    # However, the value can be non-None if the option is triggered e.g.
+    # by an environment variable, for example "PIP_NO_USE_PEP517=true".
+    if value is not None:
+        msg = """A value was passed for --no-use-pep517,
+        probably using either the PIP_NO_USE_PEP517 environment variable
+        or the "no-use-pep517" config file option. Use an appropriate value
+        of the PIP_USE_PEP517 environment variable or the "use-pep517"
+        config file option instead.
+        """
+        raise_option_error(parser, option=option, msg=msg)
+
+    # Otherwise, --no-use-pep517 was passed via the command-line.
+    parser.values.use_pep517 = False
+
+
+use_pep517 = partial(
+    Option,
+    '--use-pep517',
+    dest='use_pep517',
+    action='store_true',
+    default=None,
+    help='Use PEP 517 for building source distributions '
+         '(use --no-use-pep517 to force legacy behaviour).'
+)  # type: Any
+
+no_use_pep517 = partial(
+    Option,
+    '--no-use-pep517',
+    dest='use_pep517',
+    action='callback',
+    callback=_handle_no_use_pep517,
+    default=None,
+    help=SUPPRESS_HELP
+)  # type: Any
+
+install_options = partial(
+    Option,
+    '--install-option',
+    dest='install_options',
+    action='append',
+    metavar='options',
+    help="Extra arguments to be supplied to the setup.py install "
+         "command (use like --install-option=\"--install-scripts=/usr/local/"
+         "bin\"). Use multiple --install-option options to pass multiple "
+         "options to setup.py install. If you are using an option with a "
+         "directory path, be sure to use absolute path.",
+)  # type: Callable[..., Option]
+
+global_options = partial(
+    Option,
+    '--global-option',
+    dest='global_options',
+    action='append',
+    metavar='options',
+    help="Extra global options to be supplied to the setup.py "
+         "call before the install command.",
+)  # type: Callable[..., Option]
+
+no_clean = partial(
+    Option,
+    '--no-clean',
+    action='store_true',
+    default=False,
+    help="Don't clean up build directories."
+)  # type: Callable[..., Option]
+
+pre = partial(
+    Option,
+    '--pre',
+    action='store_true',
+    default=False,
+    help="Include pre-release and development versions. By default, "
+         "pip only finds stable versions.",
+)  # type: Callable[..., Option]
+
+disable_pip_version_check = partial(
+    Option,
+    "--disable-pip-version-check",
+    dest="disable_pip_version_check",
+    action="store_true",
+    default=False,
+    help="Don't periodically check PyPI to determine whether a new version "
+         "of pip is available for download. Implied with --no-index.",
+)  # type: Callable[..., Option]
+
+
+# Deprecated, Remove later
+always_unzip = partial(
+    Option,
+    '-Z', '--always-unzip',
+    dest='always_unzip',
+    action='store_true',
+    help=SUPPRESS_HELP,
+)  # type: Callable[..., Option]
+
+
+def _handle_merge_hash(option, opt_str, value, parser):
+    # type: (Option, str, str, OptionParser) -> None
+    """Given a value spelled "algo:digest", append the digest to a list
+    pointed to in a dict by the algo name."""
+    if not parser.values.hashes:
+        parser.values.hashes = {}
+    try:
+        algo, digest = value.split(':', 1)
+    except ValueError:
+        parser.error('Arguments to %s must be a hash name '
+                     'followed by a value, like --hash=sha256:abcde...' %
+                     opt_str)
+    if algo not in STRONG_HASHES:
+        parser.error('Allowed hash algorithms for %s are %s.' %
+                     (opt_str, ', '.join(STRONG_HASHES)))
+    parser.values.hashes.setdefault(algo, []).append(digest)
+
+
+hash = partial(
+    Option,
+    '--hash',
+    # Hash values eventually end up in InstallRequirement.hashes due to
+    # __dict__ copying in process_line().
+    dest='hashes',
+    action='callback',
+    callback=_handle_merge_hash,
+    type='string',
+    help="Verify that the package's archive matches this "
+         'hash before installing. Example: --hash=sha256:abcdef...',
+)  # type: Callable[..., Option]
+
+
+require_hashes = partial(
+    Option,
+    '--require-hashes',
+    dest='require_hashes',
+    action='store_true',
+    default=False,
+    help='Require a hash to check each requirement against, for '
+         'repeatable installs. This option is implied when any package in a '
+         'requirements file has a --hash option.',
+)  # type: Callable[..., Option]
+
+
+list_path = partial(
+    Option,
+    '--path',
+    dest='path',
+    action='append',
+    help='Restrict to the specified installation path for listing '
+         'packages (can be used multiple times).'
+)  # type: Callable[..., Option]
+
+
+def check_list_path_option(options):
+    # type: (Values) -> None
+    if options.path and (options.user or options.local):
+        raise CommandError(
+            "Cannot combine '--path' with '--user' or '--local'"
+        )
+
+
+##########
+# groups #
+##########
+
+general_group = {
+    'name': 'General Options',
+    'options': [
+        help_,
+        isolated_mode,
+        require_virtualenv,
+        verbose,
+        version,
+        quiet,
+        log,
+        no_input,
+        proxy,
+        retries,
+        timeout,
+        skip_requirements_regex,
+        exists_action,
+        trusted_host,
+        cert,
+        client_cert,
+        cache_dir,
+        no_cache,
+        disable_pip_version_check,
+        no_color,
+    ]
+}  # type: Dict[str, Any]
+
+index_group = {
+    'name': 'Package Index Options',
+    'options': [
+        index_url,
+        extra_index_url,
+        no_index,
+        find_links,
+    ]
+}  # type: Dict[str, Any]
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e1658fa5e5e498bcfa84702ed1a53dfcec071ff
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
@@ -0,0 +1,2 @@
+from .file_cache import FileCache  # noqa
+from .redis_cache import RedisCache  # noqa
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ba00806cc31cd92e44d022aac4d8a59f0260d84
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
@@ -0,0 +1,146 @@
+import hashlib
+import os
+from textwrap import dedent
+
+from ..cache import BaseCache
+from ..controller import CacheController
+
+try:
+    FileNotFoundError
+except NameError:
+    # py2.X
+    FileNotFoundError = (IOError, OSError)
+
+
+def _secure_open_write(filename, fmode):
+    # We only want to write to this file, so open it in write only mode
+    flags = os.O_WRONLY
+
+    # os.O_CREAT | os.O_EXCL will fail if the file already exists, so we only
+    #  will open *new* files.
+    # We specify this because we want to ensure that the mode we pass is the
+    # mode of the file.
+    flags |= os.O_CREAT | os.O_EXCL
+
+    # Do not follow symlinks to prevent someone from making a symlink that
+    # we follow and insecurely open a cache file.
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+
+    # On Windows we'll mark this file as binary
+    if hasattr(os, "O_BINARY"):
+        flags |= os.O_BINARY
+
+    # Before we open our file, we want to delete any existing file that is
+    # there
+    try:
+        os.remove(filename)
+    except (IOError, OSError):
+        # The file must not exist already, so we can just skip ahead to opening
+        pass
+
+    # Open our file, the use of os.O_CREAT | os.O_EXCL will ensure that if a
+    # race condition happens between the os.remove and this line, that an
+    # error will be raised. Because we utilize a lockfile this should only
+    # happen if someone is attempting to attack us.
+    fd = os.open(filename, flags, fmode)
+    try:
+        return os.fdopen(fd, "wb")
+
+    except:
+        # An error occurred wrapping our FD in a file object
+        os.close(fd)
+        raise
+
+
+class FileCache(BaseCache):
+
+    def __init__(
+        self,
+        directory,
+        forever=False,
+        filemode=0o0600,
+        dirmode=0o0700,
+        use_dir_lock=None,
+        lock_class=None,
+    ):
+
+        if use_dir_lock is not None and lock_class is not None:
+            raise ValueError("Cannot use use_dir_lock and lock_class together")
+
+        try:
+            from pip._vendor.lockfile import LockFile
+            from pip._vendor.lockfile.mkdirlockfile import MkdirLockFile
+        except ImportError:
+            notice = dedent(
+                """
+            NOTE: In order to use the FileCache you must have
+            lockfile installed. You can install it via pip:
+              pip install lockfile
+            """
+            )
+            raise ImportError(notice)
+
+        else:
+            if use_dir_lock:
+                lock_class = MkdirLockFile
+
+            elif lock_class is None:
+                lock_class = LockFile
+
+        self.directory = directory
+        self.forever = forever
+        self.filemode = filemode
+        self.dirmode = dirmode
+        self.lock_class = lock_class
+
+    @staticmethod
+    def encode(x):
+        return hashlib.sha224(x.encode()).hexdigest()
+
+    def _fn(self, name):
+        # NOTE: This method should not change as some may depend on it.
+        #       See: https://github.com/ionrock/cachecontrol/issues/63
+        hashed = self.encode(name)
+        parts = list(hashed[:5]) + [hashed]
+        return os.path.join(self.directory, *parts)
+
+    def get(self, key):
+        name = self._fn(key)
+        try:
+            with open(name, "rb") as fh:
+                return fh.read()
+
+        except FileNotFoundError:
+            return None
+
+    def set(self, key, value):
+        name = self._fn(key)
+
+        # Make sure the directory exists
+        try:
+            os.makedirs(os.path.dirname(name), self.dirmode)
+        except (IOError, OSError):
+            pass
+
+        with self.lock_class(name) as lock:
+            # Write our actual file
+            with _secure_open_write(lock.path, self.filemode) as fh:
+                fh.write(value)
+
+    def delete(self, key):
+        name = self._fn(key)
+        if not self.forever:
+            try:
+                os.remove(name)
+            except FileNotFoundError:
+                pass
+
+
+def url_to_file_path(url, filecache):
+    """Return the file cache path based on the URL.
+
+    This does not ensure the file exists!
+    """
+    key = CacheController.cache_url(url)
+    return filecache._fn(key)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed705ce7df63140ec54a8eee1ccae2b1dcd41950
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
@@ -0,0 +1,33 @@
+from __future__ import division
+
+from datetime import datetime
+from pip._vendor.cachecontrol.cache import BaseCache
+
+
+class RedisCache(BaseCache):
+
+    def __init__(self, conn):
+        self.conn = conn
+
+    def get(self, key):
+        return self.conn.get(key)
+
+    def set(self, key, value, expires=None):
+        if not expires:
+            self.conn.set(key, value)
+        else:
+            expires = expires - datetime.utcnow()
+            self.conn.setex(key, int(expires.total_seconds()), value)
+
+    def delete(self, key):
+        self.conn.delete(key)
+
+    def clear(self):
+        """Helper for clearing all the keys in a database. Use with
+        caution!"""
+        for key in self.conn.keys():
+            self.conn.delete(key)
+
+    def close(self):
+        """Redis uses connection pooling, no need to close the connection."""
+        pass
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/__init__.py
@@ -0,0 +1 @@
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/chardetect.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/chardetect.py
new file mode 100644
index 0000000000000000000000000000000000000000..c61136b639e57a46acd72d2b6b7142a61979d694
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cli/chardetect.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""
+Script which takes one or more file paths and reports on their detected
+encodings
+
+Example::
+
+    % chardetect somefile someotherfile
+    somefile: windows-1252 with confidence 0.5
+    someotherfile: ascii with confidence 1.0
+
+If no paths are provided, it takes its input from stdin.
+
+"""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import argparse
+import sys
+
+from pip._vendor.chardet import __version__
+from pip._vendor.chardet.compat import PY2
+from pip._vendor.chardet.universaldetector import UniversalDetector
+
+
+def description_of(lines, name='stdin'):
+    """
+    Return a string describing the probable encoding of a file or
+    list of strings.
+
+    :param lines: The lines to get the encoding of.
+    :type lines: Iterable of bytes
+    :param name: Name of file or collection of lines
+    :type name: str
+    """
+    u = UniversalDetector()
+    for line in lines:
+        line = bytearray(line)
+        u.feed(line)
+        # shortcut out of the loop to save reading further - particularly useful if we read a BOM.
+        if u.done:
+            break
+    u.close()
+    result = u.result
+    if PY2:
+        name = name.decode(sys.getfilesystemencoding(), 'ignore')
+    if result['encoding']:
+        return '{0}: {1} with confidence {2}'.format(name, result['encoding'],
+                                                     result['confidence'])
+    else:
+        return '{0}: no result'.format(name)
+
+
+def main(argv=None):
+    """
+    Handles command line arguments and gets things started.
+
+    :param argv: List of arguments, as if specified on the command-line.
+                 If None, ``sys.argv[1:]`` is used instead.
+    :type argv: list of str
+    """
+    # Get command line arguments
+    parser = argparse.ArgumentParser(
+        description="Takes one or more file paths and reports their detected \
+                     encodings")
+    parser.add_argument('input',
+                        help='File whose encoding we would like to determine. \
+                              (default: stdin)',
+                        type=argparse.FileType('rb'), nargs='*',
+                        default=[sys.stdin if PY2 else sys.stdin.buffer])
+    parser.add_argument('--version', action='version',
+                        version='%(prog)s {0}'.format(__version__))
+    args = parser.parse_args(argv)
+
+    for f in args.input:
+        if f.isatty():
+            print("You are running chardetect interactively. Press " +
+                  "CTRL-D twice at the start of a blank line to signal the " +
+                  "end of your input. If you want help, run chardetect " +
+                  "--help\n", file=sys.stderr)
+        print(description_of(f, f.name))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/enums.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/enums.py
new file mode 100644
index 0000000000000000000000000000000000000000..04512072251c429e63ed110cdbafaf4b3cca3412
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/enums.py
@@ -0,0 +1,76 @@
+"""
+All of the Enums that are used throughout the chardet package.
+
+:author: Dan Blanchard (dan.blanchard@gmail.com)
+"""
+
+
+class InputState(object):
+    """
+    This enum represents the different states a universal detector can be in.
+    """
+    PURE_ASCII = 0
+    ESC_ASCII = 1
+    HIGH_BYTE = 2
+
+
+class LanguageFilter(object):
+    """
+    This enum represents the different language filters we can apply to a
+    ``UniversalDetector``.
+    """
+    CHINESE_SIMPLIFIED = 0x01
+    CHINESE_TRADITIONAL = 0x02
+    JAPANESE = 0x04
+    KOREAN = 0x08
+    NON_CJK = 0x10
+    ALL = 0x1F
+    CHINESE = CHINESE_SIMPLIFIED | CHINESE_TRADITIONAL
+    CJK = CHINESE | JAPANESE | KOREAN
+
+
+class ProbingState(object):
+    """
+    This enum represents the different states a prober can be in.
+    """
+    DETECTING = 0
+    FOUND_IT = 1
+    NOT_ME = 2
+
+
+class MachineState(object):
+    """
+    This enum represents the different states a state machine can be in.
+    """
+    START = 0
+    ERROR = 1
+    ITS_ME = 2
+
+
+class SequenceLikelihood(object):
+    """
+    This enum represents the likelihood of a character following the previous one.
+    """
+    NEGATIVE = 0
+    UNLIKELY = 1
+    LIKELY = 2
+    POSITIVE = 3
+
+    @classmethod
+    def get_num_categories(cls):
+        """:returns: The number of likelihood categories in the enum."""
+        return 4
+
+
+class CharacterCategory(object):
+    """
+    This enum represents the different categories language models for
+    ``SingleByteCharsetProber`` put characters into.
+
+    Anything less than CONTROL is considered a letter.
+    """
+    UNDEFINED = 255
+    LINE_BREAK = 254
+    SYMBOL = 253
+    DIGIT = 252
+    CONTROL = 251
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escprober.py
new file mode 100644
index 0000000000000000000000000000000000000000..c70493f2b131b32378612044f30173eabbfbc3f4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escprober.py
@@ -0,0 +1,101 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .charsetprober import CharSetProber
+from .codingstatemachine import CodingStateMachine
+from .enums import LanguageFilter, ProbingState, MachineState
+from .escsm import (HZ_SM_MODEL, ISO2022CN_SM_MODEL, ISO2022JP_SM_MODEL,
+                    ISO2022KR_SM_MODEL)
+
+
+class EscCharSetProber(CharSetProber):
+    """
+    This CharSetProber uses a "code scheme" approach for detecting encodings,
+    whereby easily recognizable escape or shift sequences are relied on to
+    identify these encodings.
+    """
+
+    def __init__(self, lang_filter=None):
+        super(EscCharSetProber, self).__init__(lang_filter=lang_filter)
+        self.coding_sm = []
+        if self.lang_filter & LanguageFilter.CHINESE_SIMPLIFIED:
+            self.coding_sm.append(CodingStateMachine(HZ_SM_MODEL))
+            self.coding_sm.append(CodingStateMachine(ISO2022CN_SM_MODEL))
+        if self.lang_filter & LanguageFilter.JAPANESE:
+            self.coding_sm.append(CodingStateMachine(ISO2022JP_SM_MODEL))
+        if self.lang_filter & LanguageFilter.KOREAN:
+            self.coding_sm.append(CodingStateMachine(ISO2022KR_SM_MODEL))
+        self.active_sm_count = None
+        self._detected_charset = None
+        self._detected_language = None
+        self._state = None
+        self.reset()
+
+    def reset(self):
+        super(EscCharSetProber, self).reset()
+        for coding_sm in self.coding_sm:
+            if not coding_sm:
+                continue
+            coding_sm.active = True
+            coding_sm.reset()
+        self.active_sm_count = len(self.coding_sm)
+        self._detected_charset = None
+        self._detected_language = None
+
+    @property
+    def charset_name(self):
+        return self._detected_charset
+
+    @property
+    def language(self):
+        return self._detected_language
+
+    def get_confidence(self):
+        if self._detected_charset:
+            return 0.99
+        else:
+            return 0.00
+
+    def feed(self, byte_str):
+        for c in byte_str:
+            for coding_sm in self.coding_sm:
+                if not coding_sm or not coding_sm.active:
+                    continue
+                coding_state = coding_sm.next_state(c)
+                if coding_state == MachineState.ERROR:
+                    coding_sm.active = False
+                    self.active_sm_count -= 1
+                    if self.active_sm_count <= 0:
+                        self._state = ProbingState.NOT_ME
+                        return self.state
+                elif coding_state == MachineState.ITS_ME:
+                    self._state = ProbingState.FOUND_IT
+                    self._detected_charset = coding_sm.get_coding_state_machine()
+                    self._detected_language = coding_sm.language
+                    return self.state
+
+        return self.state
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escsm.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escsm.py
new file mode 100644
index 0000000000000000000000000000000000000000..0069523a04969dd920ea4b43a497162157729174
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/escsm.py
@@ -0,0 +1,246 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import MachineState
+
+HZ_CLS = (
+1,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,0,0,0,0,  # 20 - 27
+0,0,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,0,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,4,0,5,2,0,  # 78 - 7f
+1,1,1,1,1,1,1,1,  # 80 - 87
+1,1,1,1,1,1,1,1,  # 88 - 8f
+1,1,1,1,1,1,1,1,  # 90 - 97
+1,1,1,1,1,1,1,1,  # 98 - 9f
+1,1,1,1,1,1,1,1,  # a0 - a7
+1,1,1,1,1,1,1,1,  # a8 - af
+1,1,1,1,1,1,1,1,  # b0 - b7
+1,1,1,1,1,1,1,1,  # b8 - bf
+1,1,1,1,1,1,1,1,  # c0 - c7
+1,1,1,1,1,1,1,1,  # c8 - cf
+1,1,1,1,1,1,1,1,  # d0 - d7
+1,1,1,1,1,1,1,1,  # d8 - df
+1,1,1,1,1,1,1,1,  # e0 - e7
+1,1,1,1,1,1,1,1,  # e8 - ef
+1,1,1,1,1,1,1,1,  # f0 - f7
+1,1,1,1,1,1,1,1,  # f8 - ff
+)
+
+HZ_ST = (
+MachineState.START,MachineState.ERROR,     3,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,# 00-07
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 08-0f
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.START,MachineState.START,     4,MachineState.ERROR,# 10-17
+     5,MachineState.ERROR,     6,MachineState.ERROR,     5,     5,     4,MachineState.ERROR,# 18-1f
+     4,MachineState.ERROR,     4,     4,     4,MachineState.ERROR,     4,MachineState.ERROR,# 20-27
+     4,MachineState.ITS_ME,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 28-2f
+)
+
+HZ_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
+
+HZ_SM_MODEL = {'class_table': HZ_CLS,
+               'class_factor': 6,
+               'state_table': HZ_ST,
+               'char_len_table': HZ_CHAR_LEN_TABLE,
+               'name': "HZ-GB-2312",
+               'language': 'Chinese'}
+
+ISO2022CN_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,0,0,0,0,  # 20 - 27
+0,3,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,4,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022CN_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 00-07
+MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 08-0f
+MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 10-17
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,# 18-1f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 20-27
+     5,     6,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 28-2f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 30-37
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.START,# 38-3f
+)
+
+ISO2022CN_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+ISO2022CN_SM_MODEL = {'class_table': ISO2022CN_CLS,
+                      'class_factor': 9,
+                      'state_table': ISO2022CN_ST,
+                      'char_len_table': ISO2022CN_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-CN",
+                      'language': 'Chinese'}
+
+ISO2022JP_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,2,2,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,7,0,0,0,  # 20 - 27
+3,0,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+6,0,4,0,8,0,0,0,  # 40 - 47
+0,9,5,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022JP_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 00-07
+MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 08-0f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 10-17
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,# 18-1f
+MachineState.ERROR,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,MachineState.ERROR,# 20-27
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     6,MachineState.ITS_ME,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,# 28-2f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,# 30-37
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 38-3f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ERROR,MachineState.START,MachineState.START,# 40-47
+)
+
+ISO2022JP_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+ISO2022JP_SM_MODEL = {'class_table': ISO2022JP_CLS,
+                      'class_factor': 10,
+                      'state_table': ISO2022JP_ST,
+                      'char_len_table': ISO2022JP_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-JP",
+                      'language': 'Japanese'}
+
+ISO2022KR_CLS = (
+2,0,0,0,0,0,0,0,  # 00 - 07
+0,0,0,0,0,0,0,0,  # 08 - 0f
+0,0,0,0,0,0,0,0,  # 10 - 17
+0,0,0,1,0,0,0,0,  # 18 - 1f
+0,0,0,0,3,0,0,0,  # 20 - 27
+0,4,0,0,0,0,0,0,  # 28 - 2f
+0,0,0,0,0,0,0,0,  # 30 - 37
+0,0,0,0,0,0,0,0,  # 38 - 3f
+0,0,0,5,0,0,0,0,  # 40 - 47
+0,0,0,0,0,0,0,0,  # 48 - 4f
+0,0,0,0,0,0,0,0,  # 50 - 57
+0,0,0,0,0,0,0,0,  # 58 - 5f
+0,0,0,0,0,0,0,0,  # 60 - 67
+0,0,0,0,0,0,0,0,  # 68 - 6f
+0,0,0,0,0,0,0,0,  # 70 - 77
+0,0,0,0,0,0,0,0,  # 78 - 7f
+2,2,2,2,2,2,2,2,  # 80 - 87
+2,2,2,2,2,2,2,2,  # 88 - 8f
+2,2,2,2,2,2,2,2,  # 90 - 97
+2,2,2,2,2,2,2,2,  # 98 - 9f
+2,2,2,2,2,2,2,2,  # a0 - a7
+2,2,2,2,2,2,2,2,  # a8 - af
+2,2,2,2,2,2,2,2,  # b0 - b7
+2,2,2,2,2,2,2,2,  # b8 - bf
+2,2,2,2,2,2,2,2,  # c0 - c7
+2,2,2,2,2,2,2,2,  # c8 - cf
+2,2,2,2,2,2,2,2,  # d0 - d7
+2,2,2,2,2,2,2,2,  # d8 - df
+2,2,2,2,2,2,2,2,  # e0 - e7
+2,2,2,2,2,2,2,2,  # e8 - ef
+2,2,2,2,2,2,2,2,  # f0 - f7
+2,2,2,2,2,2,2,2,  # f8 - ff
+)
+
+ISO2022KR_ST = (
+MachineState.START,     3,MachineState.ERROR,MachineState.START,MachineState.START,MachineState.START,MachineState.ERROR,MachineState.ERROR,# 00-07
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ITS_ME,# 08-0f
+MachineState.ITS_ME,MachineState.ITS_ME,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     4,MachineState.ERROR,MachineState.ERROR,# 10-17
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,     5,MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,# 18-1f
+MachineState.ERROR,MachineState.ERROR,MachineState.ERROR,MachineState.ITS_ME,MachineState.START,MachineState.START,MachineState.START,MachineState.START,# 20-27
+)
+
+ISO2022KR_CHAR_LEN_TABLE = (0, 0, 0, 0, 0, 0)
+
+ISO2022KR_SM_MODEL = {'class_table': ISO2022KR_CLS,
+                      'class_factor': 6,
+                      'state_table': ISO2022KR_ST,
+                      'char_len_table': ISO2022KR_CHAR_LEN_TABLE,
+                      'name': "ISO-2022-KR",
+                      'language': 'Korean'}
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/eucjpprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/eucjpprober.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ce8f7d15bad9d48a3e0363de2286093a4a28cc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/eucjpprober.py
@@ -0,0 +1,92 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .enums import ProbingState, MachineState
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCJPDistributionAnalysis
+from .jpcntx import EUCJPContextAnalysis
+from .mbcssm import EUCJP_SM_MODEL
+
+
+class EUCJPProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCJPProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCJP_SM_MODEL)
+        self.distribution_analyzer = EUCJPDistributionAnalysis()
+        self.context_analyzer = EUCJPContextAnalysis()
+        self.reset()
+
+    def reset(self):
+        super(EUCJPProber, self).reset()
+        self.context_analyzer.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-JP"
+
+    @property
+    def language(self):
+        return "Japanese"
+
+    def feed(self, byte_str):
+        for i in range(len(byte_str)):
+            # PY3K: byte_str is a byte array, so byte_str[i] is an int, not a byte
+            coding_state = self.coding_sm.next_state(byte_str[i])
+            if coding_state == MachineState.ERROR:
+                self.logger.debug('%s %s prober hit error at byte %s',
+                                  self.charset_name, self.language, i)
+                self._state = ProbingState.NOT_ME
+                break
+            elif coding_state == MachineState.ITS_ME:
+                self._state = ProbingState.FOUND_IT
+                break
+            elif coding_state == MachineState.START:
+                char_len = self.coding_sm.get_current_charlen()
+                if i == 0:
+                    self._last_char[1] = byte_str[0]
+                    self.context_analyzer.feed(self._last_char, char_len)
+                    self.distribution_analyzer.feed(self._last_char, char_len)
+                else:
+                    self.context_analyzer.feed(byte_str[i - 1:i + 1],
+                                                char_len)
+                    self.distribution_analyzer.feed(byte_str[i - 1:i + 1],
+                                                     char_len)
+
+        self._last_char[0] = byte_str[-1]
+
+        if self.state == ProbingState.DETECTING:
+            if (self.context_analyzer.got_enough_data() and
+               (self.get_confidence() > self.SHORTCUT_THRESHOLD)):
+                self._state = ProbingState.FOUND_IT
+
+        return self.state
+
+    def get_confidence(self):
+        context_conf = self.context_analyzer.get_confidence()
+        distrib_conf = self.distribution_analyzer.get_confidence()
+        return max(context_conf, distrib_conf)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrfreq.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrfreq.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68078cb9680de4cca65b1145632a37c5e751c38
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrfreq.py
@@ -0,0 +1,195 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# Sampling from about 20M text materials include literature and computer technology
+
+# 128  --> 0.79
+# 256  --> 0.92
+# 512  --> 0.986
+# 1024 --> 0.99944
+# 2048 --> 0.99999
+#
+# Idea Distribution Ratio = 0.98653 / (1-0.98653) = 73.24
+# Random Distribution Ration = 512 / (2350-512) = 0.279.
+#
+# Typical Distribution Ratio
+
+EUCKR_TYPICAL_DISTRIBUTION_RATIO = 6.0
+
+EUCKR_TABLE_SIZE = 2352
+
+# Char to FreqOrder table ,
+EUCKR_CHAR_TO_FREQ_ORDER = (
+  13, 130, 120,1396, 481,1719,1720, 328, 609, 212,1721, 707, 400, 299,1722,  87,
+1397,1723, 104, 536,1117,1203,1724,1267, 685,1268, 508,1725,1726,1727,1728,1398,
+1399,1729,1730,1731, 141, 621, 326,1057, 368,1732, 267, 488,  20,1733,1269,1734,
+ 945,1400,1735,  47, 904,1270,1736,1737, 773, 248,1738, 409, 313, 786, 429,1739,
+ 116, 987, 813,1401, 683,  75,1204, 145,1740,1741,1742,1743,  16, 847, 667, 622,
+ 708,1744,1745,1746, 966, 787, 304, 129,1747,  60, 820, 123, 676,1748,1749,1750,
+1751, 617,1752, 626,1753,1754,1755,1756, 653,1757,1758,1759,1760,1761,1762, 856,
+ 344,1763,1764,1765,1766,  89, 401, 418, 806, 905, 848,1767,1768,1769, 946,1205,
+ 709,1770,1118,1771, 241,1772,1773,1774,1271,1775, 569,1776, 999,1777,1778,1779,
+1780, 337, 751,1058,  28, 628, 254,1781, 177, 906, 270, 349, 891,1079,1782,  19,
+1783, 379,1784, 315,1785, 629, 754,1402, 559,1786, 636, 203,1206,1787, 710, 567,
+1788, 935, 814,1789,1790,1207, 766, 528,1791,1792,1208,1793,1794,1795,1796,1797,
+1403,1798,1799, 533,1059,1404,1405,1156,1406, 936, 884,1080,1800, 351,1801,1802,
+1803,1804,1805, 801,1806,1807,1808,1119,1809,1157, 714, 474,1407,1810, 298, 899,
+ 885,1811,1120, 802,1158,1812, 892,1813,1814,1408, 659,1815,1816,1121,1817,1818,
+1819,1820,1821,1822, 319,1823, 594, 545,1824, 815, 937,1209,1825,1826, 573,1409,
+1022,1827,1210,1828,1829,1830,1831,1832,1833, 556, 722, 807,1122,1060,1834, 697,
+1835, 900, 557, 715,1836,1410, 540,1411, 752,1159, 294, 597,1211, 976, 803, 770,
+1412,1837,1838,  39, 794,1413, 358,1839, 371, 925,1840, 453, 661, 788, 531, 723,
+ 544,1023,1081, 869,  91,1841, 392, 430, 790, 602,1414, 677,1082, 457,1415,1416,
+1842,1843, 475, 327,1024,1417, 795, 121,1844, 733, 403,1418,1845,1846,1847, 300,
+ 119, 711,1212, 627,1848,1272, 207,1849,1850, 796,1213, 382,1851, 519,1852,1083,
+ 893,1853,1854,1855, 367, 809, 487, 671,1856, 663,1857,1858, 956, 471, 306, 857,
+1859,1860,1160,1084,1861,1862,1863,1864,1865,1061,1866,1867,1868,1869,1870,1871,
+ 282,  96, 574,1872, 502,1085,1873,1214,1874, 907,1875,1876, 827, 977,1419,1420,
+1421, 268,1877,1422,1878,1879,1880, 308,1881,   2, 537,1882,1883,1215,1884,1885,
+ 127, 791,1886,1273,1423,1887,  34, 336, 404, 643,1888, 571, 654, 894, 840,1889,
+   0, 886,1274, 122, 575, 260, 908, 938,1890,1275, 410, 316,1891,1892, 100,1893,
+1894,1123,  48,1161,1124,1025,1895, 633, 901,1276,1896,1897, 115, 816,1898, 317,
+1899, 694,1900, 909, 734,1424, 572, 866,1425, 691,  85, 524,1010, 543, 394, 841,
+1901,1902,1903,1026,1904,1905,1906,1907,1908,1909,  30, 451, 651, 988, 310,1910,
+1911,1426, 810,1216,  93,1912,1913,1277,1217,1914, 858, 759,  45,  58, 181, 610,
+ 269,1915,1916, 131,1062, 551, 443,1000, 821,1427, 957, 895,1086,1917,1918, 375,
+1919, 359,1920, 687,1921, 822,1922, 293,1923,1924,  40, 662, 118, 692,  29, 939,
+ 887, 640, 482, 174,1925,  69,1162, 728,1428, 910,1926,1278,1218,1279, 386, 870,
+ 217, 854,1163, 823,1927,1928,1929,1930, 834,1931,  78,1932, 859,1933,1063,1934,
+1935,1936,1937, 438,1164, 208, 595,1938,1939,1940,1941,1219,1125,1942, 280, 888,
+1429,1430,1220,1431,1943,1944,1945,1946,1947,1280, 150, 510,1432,1948,1949,1950,
+1951,1952,1953,1954,1011,1087,1955,1433,1043,1956, 881,1957, 614, 958,1064,1065,
+1221,1958, 638,1001, 860, 967, 896,1434, 989, 492, 553,1281,1165,1959,1282,1002,
+1283,1222,1960,1961,1962,1963,  36, 383, 228, 753, 247, 454,1964, 876, 678,1965,
+1966,1284, 126, 464, 490, 835, 136, 672, 529, 940,1088,1435, 473,1967,1968, 467,
+  50, 390, 227, 587, 279, 378, 598, 792, 968, 240, 151, 160, 849, 882,1126,1285,
+ 639,1044, 133, 140, 288, 360, 811, 563,1027, 561, 142, 523,1969,1970,1971,   7,
+ 103, 296, 439, 407, 506, 634, 990,1972,1973,1974,1975, 645,1976,1977,1978,1979,
+1980,1981, 236,1982,1436,1983,1984,1089, 192, 828, 618, 518,1166, 333,1127,1985,
+ 818,1223,1986,1987,1988,1989,1990,1991,1992,1993, 342,1128,1286, 746, 842,1994,
+1995, 560, 223,1287,  98,   8, 189, 650, 978,1288,1996,1437,1997,  17, 345, 250,
+ 423, 277, 234, 512, 226,  97, 289,  42, 167,1998, 201,1999,2000, 843, 836, 824,
+ 532, 338, 783,1090, 182, 576, 436,1438,1439, 527, 500,2001, 947, 889,2002,2003,
+2004,2005, 262, 600, 314, 447,2006, 547,2007, 693, 738,1129,2008,  71,1440, 745,
+ 619, 688,2009, 829,2010,2011, 147,2012,  33, 948,2013,2014,  74, 224,2015,  61,
+ 191, 918, 399, 637,2016,1028,1130, 257, 902,2017,2018,2019,2020,2021,2022,2023,
+2024,2025,2026, 837,2027,2028,2029,2030, 179, 874, 591,  52, 724, 246,2031,2032,
+2033,2034,1167, 969,2035,1289, 630, 605, 911,1091,1168,2036,2037,2038,1441, 912,
+2039, 623,2040,2041, 253,1169,1290,2042,1442, 146, 620, 611, 577, 433,2043,1224,
+ 719,1170, 959, 440, 437, 534,  84, 388, 480,1131, 159, 220, 198, 679,2044,1012,
+ 819,1066,1443, 113,1225, 194, 318,1003,1029,2045,2046,2047,2048,1067,2049,2050,
+2051,2052,2053,  59, 913, 112,2054, 632,2055, 455, 144, 739,1291,2056, 273, 681,
+ 499,2057, 448,2058,2059, 760,2060,2061, 970, 384, 169, 245,1132,2062,2063, 414,
+1444,2064,2065,  41, 235,2066, 157, 252, 877, 568, 919, 789, 580,2067, 725,2068,
+2069,1292,2070,2071,1445,2072,1446,2073,2074,  55, 588,  66,1447, 271,1092,2075,
+1226,2076, 960,1013, 372,2077,2078,2079,2080,2081,1293,2082,2083,2084,2085, 850,
+2086,2087,2088,2089,2090, 186,2091,1068, 180,2092,2093,2094, 109,1227, 522, 606,
+2095, 867,1448,1093, 991,1171, 926, 353,1133,2096, 581,2097,2098,2099,1294,1449,
+1450,2100, 596,1172,1014,1228,2101,1451,1295,1173,1229,2102,2103,1296,1134,1452,
+ 949,1135,2104,2105,1094,1453,1454,1455,2106,1095,2107,2108,2109,2110,2111,2112,
+2113,2114,2115,2116,2117, 804,2118,2119,1230,1231, 805,1456, 405,1136,2120,2121,
+2122,2123,2124, 720, 701,1297, 992,1457, 927,1004,2125,2126,2127,2128,2129,2130,
+  22, 417,2131, 303,2132, 385,2133, 971, 520, 513,2134,1174,  73,1096, 231, 274,
+ 962,1458, 673,2135,1459,2136, 152,1137,2137,2138,2139,2140,1005,1138,1460,1139,
+2141,2142,2143,2144,  11, 374, 844,2145, 154,1232,  46,1461,2146, 838, 830, 721,
+1233, 106,2147,  90, 428, 462, 578, 566,1175, 352,2148,2149, 538,1234, 124,1298,
+2150,1462, 761, 565,2151, 686,2152, 649,2153,  72, 173,2154, 460, 415,2155,1463,
+2156,1235, 305,2157,2158,2159,2160,2161,2162, 579,2163,2164,2165,2166,2167, 747,
+2168,2169,2170,2171,1464, 669,2172,2173,2174,2175,2176,1465,2177,  23, 530, 285,
+2178, 335, 729,2179, 397,2180,2181,2182,1030,2183,2184, 698,2185,2186, 325,2187,
+2188, 369,2189, 799,1097,1015, 348,2190,1069, 680,2191, 851,1466,2192,2193,  10,
+2194, 613, 424,2195, 979, 108, 449, 589,  27, 172,  81,1031,  80, 774, 281, 350,
+1032, 525, 301, 582,1176,2196, 674,1045,2197,2198,1467, 730, 762,2199,2200,2201,
+2202,1468,2203, 993,2204,2205, 266,1070, 963,1140,2206,2207,2208, 664,1098, 972,
+2209,2210,2211,1177,1469,1470, 871,2212,2213,2214,2215,2216,1471,2217,2218,2219,
+2220,2221,2222,2223,2224,2225,2226,2227,1472,1236,2228,2229,2230,2231,2232,2233,
+2234,2235,1299,2236,2237, 200,2238, 477, 373,2239,2240, 731, 825, 777,2241,2242,
+2243, 521, 486, 548,2244,2245,2246,1473,1300,  53, 549, 137, 875,  76, 158,2247,
+1301,1474, 469, 396,1016, 278, 712,2248, 321, 442, 503, 767, 744, 941,1237,1178,
+1475,2249,  82, 178,1141,1179, 973,2250,1302,2251, 297,2252,2253, 570,2254,2255,
+2256,  18, 450, 206,2257, 290, 292,1142,2258, 511, 162,  99, 346, 164, 735,2259,
+1476,1477,   4, 554, 343, 798,1099,2260,1100,2261,  43, 171,1303, 139, 215,2262,
+2263, 717, 775,2264,1033, 322, 216,2265, 831,2266, 149,2267,1304,2268,2269, 702,
+1238, 135, 845, 347, 309,2270, 484,2271, 878, 655, 238,1006,1478,2272,  67,2273,
+ 295,2274,2275, 461,2276, 478, 942, 412,2277,1034,2278,2279,2280, 265,2281, 541,
+2282,2283,2284,2285,2286,  70, 852,1071,2287,2288,2289,2290,  21,  56, 509, 117,
+ 432,2291,2292, 331, 980, 552,1101, 148, 284, 105, 393,1180,1239, 755,2293, 187,
+2294,1046,1479,2295, 340,2296,  63,1047, 230,2297,2298,1305, 763,1306, 101, 800,
+ 808, 494,2299,2300,2301, 903,2302,  37,1072,  14,   5,2303,  79, 675,2304, 312,
+2305,2306,2307,2308,2309,1480,   6,1307,2310,2311,2312,   1, 470,  35,  24, 229,
+2313, 695, 210,  86, 778,  15, 784, 592, 779,  32,  77, 855, 964,2314, 259,2315,
+ 501, 380,2316,2317,  83, 981, 153, 689,1308,1481,1482,1483,2318,2319, 716,1484,
+2320,2321,2322,2323,2324,2325,1485,2326,2327, 128,  57,  68, 261,1048, 211, 170,
+1240,  31,2328,  51, 435, 742,2329,2330,2331, 635,2332, 264, 456,2333,2334,2335,
+ 425,2336,1486, 143, 507, 263, 943,2337, 363, 920,1487, 256,1488,1102, 243, 601,
+1489,2338,2339,2340,2341,2342,2343,2344, 861,2345,2346,2347,2348,2349,2350, 395,
+2351,1490,1491,  62, 535, 166, 225,2352,2353, 668, 419,1241, 138, 604, 928,2354,
+1181,2355,1492,1493,2356,2357,2358,1143,2359, 696,2360, 387, 307,1309, 682, 476,
+2361,2362, 332,  12, 222, 156,2363, 232,2364, 641, 276, 656, 517,1494,1495,1035,
+ 416, 736,1496,2365,1017, 586,2366,2367,2368,1497,2369, 242,2370,2371,2372,1498,
+2373, 965, 713,2374,2375,2376,2377, 740, 982,1499, 944,1500,1007,2378,2379,1310,
+1501,2380,2381,2382, 785, 329,2383,2384,1502,2385,2386,2387, 932,2388,1503,2389,
+2390,2391,2392,1242,2393,2394,2395,2396,2397, 994, 950,2398,2399,2400,2401,1504,
+1311,2402,2403,2404,2405,1049, 749,2406,2407, 853, 718,1144,1312,2408,1182,1505,
+2409,2410, 255, 516, 479, 564, 550, 214,1506,1507,1313, 413, 239, 444, 339,1145,
+1036,1508,1509,1314,1037,1510,1315,2411,1511,2412,2413,2414, 176, 703, 497, 624,
+ 593, 921, 302,2415, 341, 165,1103,1512,2416,1513,2417,2418,2419, 376,2420, 700,
+2421,2422,2423, 258, 768,1316,2424,1183,2425, 995, 608,2426,2427,2428,2429, 221,
+2430,2431,2432,2433,2434,2435,2436,2437, 195, 323, 726, 188, 897, 983,1317, 377,
+ 644,1050, 879,2438, 452,2439,2440,2441,2442,2443,2444, 914,2445,2446,2447,2448,
+ 915, 489,2449,1514,1184,2450,2451, 515,  64, 427, 495,2452, 583,2453, 483, 485,
+1038, 562, 213,1515, 748, 666,2454,2455,2456,2457, 334,2458, 780, 996,1008, 705,
+1243,2459,2460,2461,2462,2463, 114,2464, 493,1146, 366, 163,1516, 961,1104,2465,
+ 291,2466,1318,1105,2467,1517, 365,2468, 355, 951,1244,2469,1319,2470, 631,2471,
+2472, 218,1320, 364, 320, 756,1518,1519,1321,1520,1322,2473,2474,2475,2476, 997,
+2477,2478,2479,2480, 665,1185,2481, 916,1521,2482,2483,2484, 584, 684,2485,2486,
+ 797,2487,1051,1186,2488,2489,2490,1522,2491,2492, 370,2493,1039,1187,  65,2494,
+ 434, 205, 463,1188,2495, 125, 812, 391, 402, 826, 699, 286, 398, 155, 781, 771,
+ 585,2496, 590, 505,1073,2497, 599, 244, 219, 917,1018, 952, 646,1523,2498,1323,
+2499,2500,  49, 984, 354, 741,2501, 625,2502,1324,2503,1019, 190, 357, 757, 491,
+  95, 782, 868,2504,2505,2506,2507,2508,2509, 134,1524,1074, 422,1525, 898,2510,
+ 161,2511,2512,2513,2514, 769,2515,1526,2516,2517, 411,1325,2518, 472,1527,2519,
+2520,2521,2522,2523,2524, 985,2525,2526,2527,2528,2529,2530, 764,2531,1245,2532,
+2533,  25, 204, 311,2534, 496,2535,1052,2536,2537,2538,2539,2540,2541,2542, 199,
+ 704, 504, 468, 758, 657,1528, 196,  44, 839,1246, 272, 750,2543, 765, 862,2544,
+2545,1326,2546, 132, 615, 933,2547, 732,2548,2549,2550,1189,1529,2551, 283,1247,
+1053, 607, 929,2552,2553,2554, 930, 183, 872, 616,1040,1147,2555,1148,1020, 441,
+ 249,1075,2556,2557,2558, 466, 743,2559,2560,2561,  92, 514, 426, 420, 526,2562,
+2563,2564,2565,2566,2567,2568, 185,2569,2570,2571,2572, 776,1530, 658,2573, 362,
+2574, 361, 922,1076, 793,2575,2576,2577,2578,2579,2580,1531, 251,2581,2582,2583,
+2584,1532,  54, 612, 237,1327,2585,2586, 275, 408, 647, 111,2587,1533,1106, 465,
+   3, 458,   9,  38,2588, 107, 110, 890, 209,  26, 737, 498,2589,1534,2590, 431,
+ 202,  88,1535, 356, 287,1107, 660,1149,2591, 381,1536, 986,1150, 445,1248,1151,
+ 974,2592,2593, 846,2594, 446, 953, 184,1249,1250, 727,2595, 923, 193, 883,2596,
+2597,2598, 102, 324, 539, 817,2599, 421,1041,2600, 832,2601,  94, 175, 197, 406,
+2602, 459,2603,2604,2605,2606,2607, 330, 555,2608,2609,2610, 706,1108, 389,2611,
+2612,2613,2614, 233,2615, 833, 558, 931, 954,1251,2616,2617,1537, 546,2618,2619,
+1009,2620,2621,2622,1538, 690,1328,2623, 955,2624,1539,2625,2626, 772,2627,2628,
+2629,2630,2631, 924, 648, 863, 603,2632,2633, 934,1540, 864, 865,2634, 642,1042,
+ 670,1190,2635,2636,2637,2638, 168,2639, 652, 873, 542,1054,1541,2640,2641,2642,  # 512, 256
+)
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrprober.py
new file mode 100644
index 0000000000000000000000000000000000000000..345a060d0230ada58f769b0f6b55f43a428fc3bd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euckrprober.py
@@ -0,0 +1,47 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCKRDistributionAnalysis
+from .mbcssm import EUCKR_SM_MODEL
+
+
+class EUCKRProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCKRProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCKR_SM_MODEL)
+        self.distribution_analyzer = EUCKRDistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-KR"
+
+    @property
+    def language(self):
+        return "Korean"
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwfreq.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwfreq.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed7a995a3aa311583efa5a47e316d4490e5f3463
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwfreq.py
@@ -0,0 +1,387 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Communicator client code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+# EUCTW frequency table
+# Converted from big5 work
+# by Taiwan's Mandarin Promotion Council
+# <http:#www.edu.tw:81/mandr/>
+
+# 128  --> 0.42261
+# 256  --> 0.57851
+# 512  --> 0.74851
+# 1024 --> 0.89384
+# 2048 --> 0.97583
+#
+# Idea Distribution Ratio = 0.74851/(1-0.74851) =2.98
+# Random Distribution Ration = 512/(5401-512)=0.105
+#
+# Typical Distribution Ratio about 25% of Ideal one, still much higher than RDR
+
+EUCTW_TYPICAL_DISTRIBUTION_RATIO = 0.75
+
+# Char to FreqOrder table ,
+EUCTW_TABLE_SIZE = 5376
+
+EUCTW_CHAR_TO_FREQ_ORDER = (
+   1,1800,1506, 255,1431, 198,   9,  82,   6,7310, 177, 202,3615,1256,2808, 110,  # 2742
+3735,  33,3241, 261,  76,  44,2113,  16,2931,2184,1176, 659,3868,  26,3404,2643,  # 2758
+1198,3869,3313,4060, 410,2211, 302, 590, 361,1963,   8, 204,  58,4296,7311,1931,  # 2774
+  63,7312,7313, 317,1614,  75, 222, 159,4061,2412,1480,7314,3500,3068, 224,2809,  # 2790
+3616,   3,  10,3870,1471,  29,2774,1135,2852,1939, 873, 130,3242,1123, 312,7315,  # 2806
+4297,2051, 507, 252, 682,7316, 142,1914, 124, 206,2932,  34,3501,3173,  64, 604,  # 2822
+7317,2494,1976,1977, 155,1990, 645, 641,1606,7318,3405, 337,  72, 406,7319,  80,  # 2838
+ 630, 238,3174,1509, 263, 939,1092,2644, 756,1440,1094,3406, 449,  69,2969, 591,  # 2854
+ 179,2095, 471, 115,2034,1843,  60,  50,2970, 134, 806,1868, 734,2035,3407, 180,  # 2870
+ 995,1607, 156, 537,2893, 688,7320, 319,1305, 779,2144, 514,2374, 298,4298, 359,  # 2886
+2495,  90,2707,1338, 663,  11, 906,1099,2545,  20,2436, 182, 532,1716,7321, 732,  # 2902
+1376,4062,1311,1420,3175,  25,2312,1056, 113, 399, 382,1949, 242,3408,2467, 529,  # 2918
+3243, 475,1447,3617,7322, 117,  21, 656, 810,1297,2295,2329,3502,7323, 126,4063,  # 2934
+ 706, 456, 150, 613,4299,  71,1118,2036,4064, 145,3069,  85, 835, 486,2114,1246,  # 2950
+1426, 428, 727,1285,1015, 800, 106, 623, 303,1281,7324,2127,2354, 347,3736, 221,  # 2966
+3503,3110,7325,1955,1153,4065,  83, 296,1199,3070, 192, 624,  93,7326, 822,1897,  # 2982
+2810,3111, 795,2064, 991,1554,1542,1592,  27,  43,2853, 859, 139,1456, 860,4300,  # 2998
+ 437, 712,3871, 164,2392,3112, 695, 211,3017,2096, 195,3872,1608,3504,3505,3618,  # 3014
+3873, 234, 811,2971,2097,3874,2229,1441,3506,1615,2375, 668,2076,1638, 305, 228,  # 3030
+1664,4301, 467, 415,7327, 262,2098,1593, 239, 108, 300, 200,1033, 512,1247,2077,  # 3046
+7328,7329,2173,3176,3619,2673, 593, 845,1062,3244,  88,1723,2037,3875,1950, 212,  # 3062
+ 266, 152, 149, 468,1898,4066,4302,  77, 187,7330,3018,  37,   5,2972,7331,3876,  # 3078
+7332,7333,  39,2517,4303,2894,3177,2078,  55, 148,  74,4304, 545, 483,1474,1029,  # 3094
+1665, 217,1869,1531,3113,1104,2645,4067,  24, 172,3507, 900,3877,3508,3509,4305,  # 3110
+  32,1408,2811,1312, 329, 487,2355,2247,2708, 784,2674,   4,3019,3314,1427,1788,  # 3126
+ 188, 109, 499,7334,3620,1717,1789, 888,1217,3020,4306,7335,3510,7336,3315,1520,  # 3142
+3621,3878, 196,1034, 775,7337,7338, 929,1815, 249, 439,  38,7339,1063,7340, 794,  # 3158
+3879,1435,2296,  46, 178,3245,2065,7341,2376,7342, 214,1709,4307, 804,  35, 707,  # 3174
+ 324,3622,1601,2546, 140, 459,4068,7343,7344,1365, 839, 272, 978,2257,2572,3409,  # 3190
+2128,1363,3623,1423, 697, 100,3071,  48,  70,1231, 495,3114,2193,7345,1294,7346,  # 3206
+2079, 462, 586,1042,3246, 853, 256, 988, 185,2377,3410,1698, 434,1084,7347,3411,  # 3222
+ 314,2615,2775,4308,2330,2331, 569,2280, 637,1816,2518, 757,1162,1878,1616,3412,  # 3238
+ 287,1577,2115, 768,4309,1671,2854,3511,2519,1321,3737, 909,2413,7348,4069, 933,  # 3254
+3738,7349,2052,2356,1222,4310, 765,2414,1322, 786,4311,7350,1919,1462,1677,2895,  # 3270
+1699,7351,4312,1424,2437,3115,3624,2590,3316,1774,1940,3413,3880,4070, 309,1369,  # 3286
+1130,2812, 364,2230,1653,1299,3881,3512,3882,3883,2646, 525,1085,3021, 902,2000,  # 3302
+1475, 964,4313, 421,1844,1415,1057,2281, 940,1364,3116, 376,4314,4315,1381,   7,  # 3318
+2520, 983,2378, 336,1710,2675,1845, 321,3414, 559,1131,3022,2742,1808,1132,1313,  # 3334
+ 265,1481,1857,7352, 352,1203,2813,3247, 167,1089, 420,2814, 776, 792,1724,3513,  # 3350
+4071,2438,3248,7353,4072,7354, 446, 229, 333,2743, 901,3739,1200,1557,4316,2647,  # 3366
+1920, 395,2744,2676,3740,4073,1835, 125, 916,3178,2616,4317,7355,7356,3741,7357,  # 3382
+7358,7359,4318,3117,3625,1133,2547,1757,3415,1510,2313,1409,3514,7360,2145, 438,  # 3398
+2591,2896,2379,3317,1068, 958,3023, 461, 311,2855,2677,4074,1915,3179,4075,1978,  # 3414
+ 383, 750,2745,2617,4076, 274, 539, 385,1278,1442,7361,1154,1964, 384, 561, 210,  # 3430
+  98,1295,2548,3515,7362,1711,2415,1482,3416,3884,2897,1257, 129,7363,3742, 642,  # 3446
+ 523,2776,2777,2648,7364, 141,2231,1333,  68, 176, 441, 876, 907,4077, 603,2592,  # 3462
+ 710, 171,3417, 404, 549,  18,3118,2393,1410,3626,1666,7365,3516,4319,2898,4320,  # 3478
+7366,2973, 368,7367, 146, 366,  99, 871,3627,1543, 748, 807,1586,1185,  22,2258,  # 3494
+ 379,3743,3180,7368,3181, 505,1941,2618,1991,1382,2314,7369, 380,2357, 218, 702,  # 3510
+1817,1248,3418,3024,3517,3318,3249,7370,2974,3628, 930,3250,3744,7371,  59,7372,  # 3526
+ 585, 601,4078, 497,3419,1112,1314,4321,1801,7373,1223,1472,2174,7374, 749,1836,  # 3542
+ 690,1899,3745,1772,3885,1476, 429,1043,1790,2232,2116, 917,4079, 447,1086,1629,  # 3558
+7375, 556,7376,7377,2020,1654, 844,1090, 105, 550, 966,1758,2815,1008,1782, 686,  # 3574
+1095,7378,2282, 793,1602,7379,3518,2593,4322,4080,2933,2297,4323,3746, 980,2496,  # 3590
+ 544, 353, 527,4324, 908,2678,2899,7380, 381,2619,1942,1348,7381,1341,1252, 560,  # 3606
+3072,7382,3420,2856,7383,2053, 973, 886,2080, 143,4325,7384,7385, 157,3886, 496,  # 3622
+4081,  57, 840, 540,2038,4326,4327,3421,2117,1445, 970,2259,1748,1965,2081,4082,  # 3638
+3119,1234,1775,3251,2816,3629, 773,1206,2129,1066,2039,1326,3887,1738,1725,4083,  # 3654
+ 279,3120,  51,1544,2594, 423,1578,2130,2066, 173,4328,1879,7386,7387,1583, 264,  # 3670
+ 610,3630,4329,2439, 280, 154,7388,7389,7390,1739, 338,1282,3073, 693,2857,1411,  # 3686
+1074,3747,2440,7391,4330,7392,7393,1240, 952,2394,7394,2900,1538,2679, 685,1483,  # 3702
+4084,2468,1436, 953,4085,2054,4331, 671,2395,  79,4086,2441,3252, 608, 567,2680,  # 3718
+3422,4087,4088,1691, 393,1261,1791,2396,7395,4332,7396,7397,7398,7399,1383,1672,  # 3734
+3748,3182,1464, 522,1119, 661,1150, 216, 675,4333,3888,1432,3519, 609,4334,2681,  # 3750
+2397,7400,7401,7402,4089,3025,   0,7403,2469, 315, 231,2442, 301,3319,4335,2380,  # 3766
+7404, 233,4090,3631,1818,4336,4337,7405,  96,1776,1315,2082,7406, 257,7407,1809,  # 3782
+3632,2709,1139,1819,4091,2021,1124,2163,2778,1777,2649,7408,3074, 363,1655,3183,  # 3798
+7409,2975,7410,7411,7412,3889,1567,3890, 718, 103,3184, 849,1443, 341,3320,2934,  # 3814
+1484,7413,1712, 127,  67, 339,4092,2398, 679,1412, 821,7414,7415, 834, 738, 351,  # 3830
+2976,2146, 846, 235,1497,1880, 418,1992,3749,2710, 186,1100,2147,2746,3520,1545,  # 3846
+1355,2935,2858,1377, 583,3891,4093,2573,2977,7416,1298,3633,1078,2549,3634,2358,  # 3862
+  78,3750,3751, 267,1289,2099,2001,1594,4094, 348, 369,1274,2194,2175,1837,4338,  # 3878
+1820,2817,3635,2747,2283,2002,4339,2936,2748, 144,3321, 882,4340,3892,2749,3423,  # 3894
+4341,2901,7417,4095,1726, 320,7418,3893,3026, 788,2978,7419,2818,1773,1327,2859,  # 3910
+3894,2819,7420,1306,4342,2003,1700,3752,3521,2359,2650, 787,2022, 506, 824,3636,  # 3926
+ 534, 323,4343,1044,3322,2023,1900, 946,3424,7421,1778,1500,1678,7422,1881,4344,  # 3942
+ 165, 243,4345,3637,2521, 123, 683,4096, 764,4346,  36,3895,1792, 589,2902, 816,  # 3958
+ 626,1667,3027,2233,1639,1555,1622,3753,3896,7423,3897,2860,1370,1228,1932, 891,  # 3974
+2083,2903, 304,4097,7424, 292,2979,2711,3522, 691,2100,4098,1115,4347, 118, 662,  # 3990
+7425, 611,1156, 854,2381,1316,2861,   2, 386, 515,2904,7426,7427,3253, 868,2234,  # 4006
+1486, 855,2651, 785,2212,3028,7428,1040,3185,3523,7429,3121, 448,7430,1525,7431,  # 4022
+2164,4348,7432,3754,7433,4099,2820,3524,3122, 503, 818,3898,3123,1568, 814, 676,  # 4038
+1444, 306,1749,7434,3755,1416,1030, 197,1428, 805,2821,1501,4349,7435,7436,7437,  # 4054
+1993,7438,4350,7439,7440,2195,  13,2779,3638,2980,3124,1229,1916,7441,3756,2131,  # 4070
+7442,4100,4351,2399,3525,7443,2213,1511,1727,1120,7444,7445, 646,3757,2443, 307,  # 4086
+7446,7447,1595,3186,7448,7449,7450,3639,1113,1356,3899,1465,2522,2523,7451, 519,  # 4102
+7452, 128,2132,  92,2284,1979,7453,3900,1512, 342,3125,2196,7454,2780,2214,1980,  # 4118
+3323,7455, 290,1656,1317, 789, 827,2360,7456,3758,4352, 562, 581,3901,7457, 401,  # 4134
+4353,2248,  94,4354,1399,2781,7458,1463,2024,4355,3187,1943,7459, 828,1105,4101,  # 4150
+1262,1394,7460,4102, 605,4356,7461,1783,2862,7462,2822, 819,2101, 578,2197,2937,  # 4166
+7463,1502, 436,3254,4103,3255,2823,3902,2905,3425,3426,7464,2712,2315,7465,7466,  # 4182
+2332,2067,  23,4357, 193, 826,3759,2102, 699,1630,4104,3075, 390,1793,1064,3526,  # 4198
+7467,1579,3076,3077,1400,7468,4105,1838,1640,2863,7469,4358,4359, 137,4106, 598,  # 4214
+3078,1966, 780, 104, 974,2938,7470, 278, 899, 253, 402, 572, 504, 493,1339,7471,  # 4230
+3903,1275,4360,2574,2550,7472,3640,3029,3079,2249, 565,1334,2713, 863,  41,7473,  # 4246
+7474,4361,7475,1657,2333,  19, 463,2750,4107, 606,7476,2981,3256,1087,2084,1323,  # 4262
+2652,2982,7477,1631,1623,1750,4108,2682,7478,2864, 791,2714,2653,2334, 232,2416,  # 4278
+7479,2983,1498,7480,2654,2620, 755,1366,3641,3257,3126,2025,1609, 119,1917,3427,  # 4294
+ 862,1026,4109,7481,3904,3760,4362,3905,4363,2260,1951,2470,7482,1125, 817,4110,  # 4310
+4111,3906,1513,1766,2040,1487,4112,3030,3258,2824,3761,3127,7483,7484,1507,7485,  # 4326
+2683, 733,  40,1632,1106,2865, 345,4113, 841,2524, 230,4364,2984,1846,3259,3428,  # 4342
+7486,1263, 986,3429,7487, 735, 879, 254,1137, 857, 622,1300,1180,1388,1562,3907,  # 4358
+3908,2939, 967,2751,2655,1349, 592,2133,1692,3324,2985,1994,4114,1679,3909,1901,  # 4374
+2185,7488, 739,3642,2715,1296,1290,7489,4115,2198,2199,1921,1563,2595,2551,1870,  # 4390
+2752,2986,7490, 435,7491, 343,1108, 596,  17,1751,4365,2235,3430,3643,7492,4366,  # 4406
+ 294,3527,2940,1693, 477, 979, 281,2041,3528, 643,2042,3644,2621,2782,2261,1031,  # 4422
+2335,2134,2298,3529,4367, 367,1249,2552,7493,3530,7494,4368,1283,3325,2004, 240,  # 4438
+1762,3326,4369,4370, 836,1069,3128, 474,7495,2148,2525, 268,3531,7496,3188,1521,  # 4454
+1284,7497,1658,1546,4116,7498,3532,3533,7499,4117,3327,2684,1685,4118, 961,1673,  # 4470
+2622, 190,2005,2200,3762,4371,4372,7500, 570,2497,3645,1490,7501,4373,2623,3260,  # 4486
+1956,4374, 584,1514, 396,1045,1944,7502,4375,1967,2444,7503,7504,4376,3910, 619,  # 4502
+7505,3129,3261, 215,2006,2783,2553,3189,4377,3190,4378, 763,4119,3763,4379,7506,  # 4518
+7507,1957,1767,2941,3328,3646,1174, 452,1477,4380,3329,3130,7508,2825,1253,2382,  # 4534
+2186,1091,2285,4120, 492,7509, 638,1169,1824,2135,1752,3911, 648, 926,1021,1324,  # 4550
+4381, 520,4382, 997, 847,1007, 892,4383,3764,2262,1871,3647,7510,2400,1784,4384,  # 4566
+1952,2942,3080,3191,1728,4121,2043,3648,4385,2007,1701,3131,1551,  30,2263,4122,  # 4582
+7511,2026,4386,3534,7512, 501,7513,4123, 594,3431,2165,1821,3535,3432,3536,3192,  # 4598
+ 829,2826,4124,7514,1680,3132,1225,4125,7515,3262,4387,4126,3133,2336,7516,4388,  # 4614
+4127,7517,3912,3913,7518,1847,2383,2596,3330,7519,4389, 374,3914, 652,4128,4129,  # 4630
+ 375,1140, 798,7520,7521,7522,2361,4390,2264, 546,1659, 138,3031,2445,4391,7523,  # 4646
+2250, 612,1848, 910, 796,3765,1740,1371, 825,3766,3767,7524,2906,2554,7525, 692,  # 4662
+ 444,3032,2624, 801,4392,4130,7526,1491, 244,1053,3033,4131,4132, 340,7527,3915,  # 4678
+1041,2987, 293,1168,  87,1357,7528,1539, 959,7529,2236, 721, 694,4133,3768, 219,  # 4694
+1478, 644,1417,3331,2656,1413,1401,1335,1389,3916,7530,7531,2988,2362,3134,1825,  # 4710
+ 730,1515, 184,2827,  66,4393,7532,1660,2943, 246,3332, 378,1457, 226,3433, 975,  # 4726
+3917,2944,1264,3537, 674, 696,7533, 163,7534,1141,2417,2166, 713,3538,3333,4394,  # 4742
+3918,7535,7536,1186,  15,7537,1079,1070,7538,1522,3193,3539, 276,1050,2716, 758,  # 4758
+1126, 653,2945,3263,7539,2337, 889,3540,3919,3081,2989, 903,1250,4395,3920,3434,  # 4774
+3541,1342,1681,1718, 766,3264, 286,  89,2946,3649,7540,1713,7541,2597,3334,2990,  # 4790
+7542,2947,2215,3194,2866,7543,4396,2498,2526, 181, 387,1075,3921, 731,2187,3335,  # 4806
+7544,3265, 310, 313,3435,2299, 770,4134,  54,3034, 189,4397,3082,3769,3922,7545,  # 4822
+1230,1617,1849, 355,3542,4135,4398,3336, 111,4136,3650,1350,3135,3436,3035,4137,  # 4838
+2149,3266,3543,7546,2784,3923,3924,2991, 722,2008,7547,1071, 247,1207,2338,2471,  # 4854
+1378,4399,2009, 864,1437,1214,4400, 373,3770,1142,2216, 667,4401, 442,2753,2555,  # 4870
+3771,3925,1968,4138,3267,1839, 837, 170,1107, 934,1336,1882,7548,7549,2118,4139,  # 4886
+2828, 743,1569,7550,4402,4140, 582,2384,1418,3437,7551,1802,7552, 357,1395,1729,  # 4902
+3651,3268,2418,1564,2237,7553,3083,3772,1633,4403,1114,2085,4141,1532,7554, 482,  # 4918
+2446,4404,7555,7556,1492, 833,1466,7557,2717,3544,1641,2829,7558,1526,1272,3652,  # 4934
+4142,1686,1794, 416,2556,1902,1953,1803,7559,3773,2785,3774,1159,2316,7560,2867,  # 4950
+4405,1610,1584,3036,2419,2754, 443,3269,1163,3136,7561,7562,3926,7563,4143,2499,  # 4966
+3037,4406,3927,3137,2103,1647,3545,2010,1872,4144,7564,4145, 431,3438,7565, 250,  # 4982
+  97,  81,4146,7566,1648,1850,1558, 160, 848,7567, 866, 740,1694,7568,2201,2830,  # 4998
+3195,4147,4407,3653,1687, 950,2472, 426, 469,3196,3654,3655,3928,7569,7570,1188,  # 5014
+ 424,1995, 861,3546,4148,3775,2202,2685, 168,1235,3547,4149,7571,2086,1674,4408,  # 5030
+3337,3270, 220,2557,1009,7572,3776, 670,2992, 332,1208, 717,7573,7574,3548,2447,  # 5046
+3929,3338,7575, 513,7576,1209,2868,3339,3138,4409,1080,7577,7578,7579,7580,2527,  # 5062
+3656,3549, 815,1587,3930,3931,7581,3550,3439,3777,1254,4410,1328,3038,1390,3932,  # 5078
+1741,3933,3778,3934,7582, 236,3779,2448,3271,7583,7584,3657,3780,1273,3781,4411,  # 5094
+7585, 308,7586,4412, 245,4413,1851,2473,1307,2575, 430, 715,2136,2449,7587, 270,  # 5110
+ 199,2869,3935,7588,3551,2718,1753, 761,1754, 725,1661,1840,4414,3440,3658,7589,  # 5126
+7590, 587,  14,3272, 227,2598, 326, 480,2265, 943,2755,3552, 291, 650,1883,7591,  # 5142
+1702,1226, 102,1547,  62,3441, 904,4415,3442,1164,4150,7592,7593,1224,1548,2756,  # 5158
+ 391, 498,1493,7594,1386,1419,7595,2055,1177,4416, 813, 880,1081,2363, 566,1145,  # 5174
+4417,2286,1001,1035,2558,2599,2238, 394,1286,7596,7597,2068,7598,  86,1494,1730,  # 5190
+3936, 491,1588, 745, 897,2948, 843,3340,3937,2757,2870,3273,1768, 998,2217,2069,  # 5206
+ 397,1826,1195,1969,3659,2993,3341, 284,7599,3782,2500,2137,2119,1903,7600,3938,  # 5222
+2150,3939,4151,1036,3443,1904, 114,2559,4152, 209,1527,7601,7602,2949,2831,2625,  # 5238
+2385,2719,3139, 812,2560,7603,3274,7604,1559, 737,1884,3660,1210, 885,  28,2686,  # 5254
+3553,3783,7605,4153,1004,1779,4418,7606, 346,1981,2218,2687,4419,3784,1742, 797,  # 5270
+1642,3940,1933,1072,1384,2151, 896,3941,3275,3661,3197,2871,3554,7607,2561,1958,  # 5286
+4420,2450,1785,7608,7609,7610,3942,4154,1005,1308,3662,4155,2720,4421,4422,1528,  # 5302
+2600, 161,1178,4156,1982, 987,4423,1101,4157, 631,3943,1157,3198,2420,1343,1241,  # 5318
+1016,2239,2562, 372, 877,2339,2501,1160, 555,1934, 911,3944,7611, 466,1170, 169,  # 5334
+1051,2907,2688,3663,2474,2994,1182,2011,2563,1251,2626,7612, 992,2340,3444,1540,  # 5350
+2721,1201,2070,2401,1996,2475,7613,4424, 528,1922,2188,1503,1873,1570,2364,3342,  # 5366
+3276,7614, 557,1073,7615,1827,3445,2087,2266,3140,3039,3084, 767,3085,2786,4425,  # 5382
+1006,4158,4426,2341,1267,2176,3664,3199, 778,3945,3200,2722,1597,2657,7616,4427,  # 5398
+7617,3446,7618,7619,7620,3277,2689,1433,3278, 131,  95,1504,3946, 723,4159,3141,  # 5414
+1841,3555,2758,2189,3947,2027,2104,3665,7621,2995,3948,1218,7622,3343,3201,3949,  # 5430
+4160,2576, 248,1634,3785, 912,7623,2832,3666,3040,3786, 654,  53,7624,2996,7625,  # 5446
+1688,4428, 777,3447,1032,3950,1425,7626, 191, 820,2120,2833, 971,4429, 931,3202,  # 5462
+ 135, 664, 783,3787,1997, 772,2908,1935,3951,3788,4430,2909,3203, 282,2723, 640,  # 5478
+1372,3448,1127, 922, 325,3344,7627,7628, 711,2044,7629,7630,3952,2219,2787,1936,  # 5494
+3953,3345,2220,2251,3789,2300,7631,4431,3790,1258,3279,3954,3204,2138,2950,3955,  # 5510
+3956,7632,2221, 258,3205,4432, 101,1227,7633,3280,1755,7634,1391,3281,7635,2910,  # 5526
+2056, 893,7636,7637,7638,1402,4161,2342,7639,7640,3206,3556,7641,7642, 878,1325,  # 5542
+1780,2788,4433, 259,1385,2577, 744,1183,2267,4434,7643,3957,2502,7644, 684,1024,  # 5558
+4162,7645, 472,3557,3449,1165,3282,3958,3959, 322,2152, 881, 455,1695,1152,1340,  # 5574
+ 660, 554,2153,4435,1058,4436,4163, 830,1065,3346,3960,4437,1923,7646,1703,1918,  # 5590
+7647, 932,2268, 122,7648,4438, 947, 677,7649,3791,2627, 297,1905,1924,2269,4439,  # 5606
+2317,3283,7650,7651,4164,7652,4165,  84,4166, 112, 989,7653, 547,1059,3961, 701,  # 5622
+3558,1019,7654,4167,7655,3450, 942, 639, 457,2301,2451, 993,2951, 407, 851, 494,  # 5638
+4440,3347, 927,7656,1237,7657,2421,3348, 573,4168, 680, 921,2911,1279,1874, 285,  # 5654
+ 790,1448,1983, 719,2167,7658,7659,4441,3962,3963,1649,7660,1541, 563,7661,1077,  # 5670
+7662,3349,3041,3451, 511,2997,3964,3965,3667,3966,1268,2564,3350,3207,4442,4443,  # 5686
+7663, 535,1048,1276,1189,2912,2028,3142,1438,1373,2834,2952,1134,2012,7664,4169,  # 5702
+1238,2578,3086,1259,7665, 700,7666,2953,3143,3668,4170,7667,4171,1146,1875,1906,  # 5718
+4444,2601,3967, 781,2422, 132,1589, 203, 147, 273,2789,2402, 898,1786,2154,3968,  # 5734
+3969,7668,3792,2790,7669,7670,4445,4446,7671,3208,7672,1635,3793, 965,7673,1804,  # 5750
+2690,1516,3559,1121,1082,1329,3284,3970,1449,3794,  65,1128,2835,2913,2759,1590,  # 5766
+3795,7674,7675,  12,2658,  45, 976,2579,3144,4447, 517,2528,1013,1037,3209,7676,  # 5782
+3796,2836,7677,3797,7678,3452,7679,2602, 614,1998,2318,3798,3087,2724,2628,7680,  # 5798
+2580,4172, 599,1269,7681,1810,3669,7682,2691,3088, 759,1060, 489,1805,3351,3285,  # 5814
+1358,7683,7684,2386,1387,1215,2629,2252, 490,7685,7686,4173,1759,2387,2343,7687,  # 5830
+4448,3799,1907,3971,2630,1806,3210,4449,3453,3286,2760,2344, 874,7688,7689,3454,  # 5846
+3670,1858,  91,2914,3671,3042,3800,4450,7690,3145,3972,2659,7691,3455,1202,1403,  # 5862
+3801,2954,2529,1517,2503,4451,3456,2504,7692,4452,7693,2692,1885,1495,1731,3973,  # 5878
+2365,4453,7694,2029,7695,7696,3974,2693,1216, 237,2581,4174,2319,3975,3802,4454,  # 5894
+4455,2694,3560,3457, 445,4456,7697,7698,7699,7700,2761,  61,3976,3672,1822,3977,  # 5910
+7701, 687,2045, 935, 925, 405,2660, 703,1096,1859,2725,4457,3978,1876,1367,2695,  # 5926
+3352, 918,2105,1781,2476, 334,3287,1611,1093,4458, 564,3146,3458,3673,3353, 945,  # 5942
+2631,2057,4459,7702,1925, 872,4175,7703,3459,2696,3089, 349,4176,3674,3979,4460,  # 5958
+3803,4177,3675,2155,3980,4461,4462,4178,4463,2403,2046, 782,3981, 400, 251,4179,  # 5974
+1624,7704,7705, 277,3676, 299,1265, 476,1191,3804,2121,4180,4181,1109, 205,7706,  # 5990
+2582,1000,2156,3561,1860,7707,7708,7709,4464,7710,4465,2565, 107,2477,2157,3982,  # 6006
+3460,3147,7711,1533, 541,1301, 158, 753,4182,2872,3562,7712,1696, 370,1088,4183,  # 6022
+4466,3563, 579, 327, 440, 162,2240, 269,1937,1374,3461, 968,3043,  56,1396,3090,  # 6038
+2106,3288,3354,7713,1926,2158,4467,2998,7714,3564,7715,7716,3677,4468,2478,7717,  # 6054
+2791,7718,1650,4469,7719,2603,7720,7721,3983,2661,3355,1149,3356,3984,3805,3985,  # 6070
+7722,1076,  49,7723, 951,3211,3289,3290, 450,2837, 920,7724,1811,2792,2366,4184,  # 6086
+1908,1138,2367,3806,3462,7725,3212,4470,1909,1147,1518,2423,4471,3807,7726,4472,  # 6102
+2388,2604, 260,1795,3213,7727,7728,3808,3291, 708,7729,3565,1704,7730,3566,1351,  # 6118
+1618,3357,2999,1886, 944,4185,3358,4186,3044,3359,4187,7731,3678, 422, 413,1714,  # 6134
+3292, 500,2058,2345,4188,2479,7732,1344,1910, 954,7733,1668,7734,7735,3986,2404,  # 6150
+4189,3567,3809,4190,7736,2302,1318,2505,3091, 133,3092,2873,4473, 629,  31,2838,  # 6166
+2697,3810,4474, 850, 949,4475,3987,2955,1732,2088,4191,1496,1852,7737,3988, 620,  # 6182
+3214, 981,1242,3679,3360,1619,3680,1643,3293,2139,2452,1970,1719,3463,2168,7738,  # 6198
+3215,7739,7740,3361,1828,7741,1277,4476,1565,2047,7742,1636,3568,3093,7743, 869,  # 6214
+2839, 655,3811,3812,3094,3989,3000,3813,1310,3569,4477,7744,7745,7746,1733, 558,  # 6230
+4478,3681, 335,1549,3045,1756,4192,3682,1945,3464,1829,1291,1192, 470,2726,2107,  # 6246
+2793, 913,1054,3990,7747,1027,7748,3046,3991,4479, 982,2662,3362,3148,3465,3216,  # 6262
+3217,1946,2794,7749, 571,4480,7750,1830,7751,3570,2583,1523,2424,7752,2089, 984,  # 6278
+4481,3683,1959,7753,3684, 852, 923,2795,3466,3685, 969,1519, 999,2048,2320,1705,  # 6294
+7754,3095, 615,1662, 151, 597,3992,2405,2321,1049, 275,4482,3686,4193, 568,3687,  # 6310
+3571,2480,4194,3688,7755,2425,2270, 409,3218,7756,1566,2874,3467,1002, 769,2840,  # 6326
+ 194,2090,3149,3689,2222,3294,4195, 628,1505,7757,7758,1763,2177,3001,3993, 521,  # 6342
+1161,2584,1787,2203,2406,4483,3994,1625,4196,4197, 412,  42,3096, 464,7759,2632,  # 6358
+4484,3363,1760,1571,2875,3468,2530,1219,2204,3814,2633,2140,2368,4485,4486,3295,  # 6374
+1651,3364,3572,7760,7761,3573,2481,3469,7762,3690,7763,7764,2271,2091, 460,7765,  # 6390
+4487,7766,3002, 962, 588,3574, 289,3219,2634,1116,  52,7767,3047,1796,7768,7769,  # 6406
+7770,1467,7771,1598,1143,3691,4198,1984,1734,1067,4488,1280,3365, 465,4489,1572,  # 6422
+ 510,7772,1927,2241,1812,1644,3575,7773,4490,3692,7774,7775,2663,1573,1534,7776,  # 6438
+7777,4199, 536,1807,1761,3470,3815,3150,2635,7778,7779,7780,4491,3471,2915,1911,  # 6454
+2796,7781,3296,1122, 377,3220,7782, 360,7783,7784,4200,1529, 551,7785,2059,3693,  # 6470
+1769,2426,7786,2916,4201,3297,3097,2322,2108,2030,4492,1404, 136,1468,1479, 672,  # 6486
+1171,3221,2303, 271,3151,7787,2762,7788,2049, 678,2727, 865,1947,4493,7789,2013,  # 6502
+3995,2956,7790,2728,2223,1397,3048,3694,4494,4495,1735,2917,3366,3576,7791,3816,  # 6518
+ 509,2841,2453,2876,3817,7792,7793,3152,3153,4496,4202,2531,4497,2304,1166,1010,  # 6534
+ 552, 681,1887,7794,7795,2957,2958,3996,1287,1596,1861,3154, 358, 453, 736, 175,  # 6550
+ 478,1117, 905,1167,1097,7796,1853,1530,7797,1706,7798,2178,3472,2287,3695,3473,  # 6566
+3577,4203,2092,4204,7799,3367,1193,2482,4205,1458,2190,2205,1862,1888,1421,3298,  # 6582
+2918,3049,2179,3474, 595,2122,7800,3997,7801,7802,4206,1707,2636, 223,3696,1359,  # 6598
+ 751,3098, 183,3475,7803,2797,3003, 419,2369, 633, 704,3818,2389, 241,7804,7805,  # 6614
+7806, 838,3004,3697,2272,2763,2454,3819,1938,2050,3998,1309,3099,2242,1181,7807,  # 6630
+1136,2206,3820,2370,1446,4207,2305,4498,7808,7809,4208,1055,2605, 484,3698,7810,  # 6646
+3999, 625,4209,2273,3368,1499,4210,4000,7811,4001,4211,3222,2274,2275,3476,7812,  # 6662
+7813,2764, 808,2606,3699,3369,4002,4212,3100,2532, 526,3370,3821,4213, 955,7814,  # 6678
+1620,4214,2637,2427,7815,1429,3700,1669,1831, 994, 928,7816,3578,1260,7817,7818,  # 6694
+7819,1948,2288, 741,2919,1626,4215,2729,2455, 867,1184, 362,3371,1392,7820,7821,  # 6710
+4003,4216,1770,1736,3223,2920,4499,4500,1928,2698,1459,1158,7822,3050,3372,2877,  # 6726
+1292,1929,2506,2842,3701,1985,1187,2071,2014,2607,4217,7823,2566,2507,2169,3702,  # 6742
+2483,3299,7824,3703,4501,7825,7826, 666,1003,3005,1022,3579,4218,7827,4502,1813,  # 6758
+2253, 574,3822,1603, 295,1535, 705,3823,4219, 283, 858, 417,7828,7829,3224,4503,  # 6774
+4504,3051,1220,1889,1046,2276,2456,4004,1393,1599, 689,2567, 388,4220,7830,2484,  # 6790
+ 802,7831,2798,3824,2060,1405,2254,7832,4505,3825,2109,1052,1345,3225,1585,7833,  # 6806
+ 809,7834,7835,7836, 575,2730,3477, 956,1552,1469,1144,2323,7837,2324,1560,2457,  # 6822
+3580,3226,4005, 616,2207,3155,2180,2289,7838,1832,7839,3478,4506,7840,1319,3704,  # 6838
+3705,1211,3581,1023,3227,1293,2799,7841,7842,7843,3826, 607,2306,3827, 762,2878,  # 6854
+1439,4221,1360,7844,1485,3052,7845,4507,1038,4222,1450,2061,2638,4223,1379,4508,  # 6870
+2585,7846,7847,4224,1352,1414,2325,2921,1172,7848,7849,3828,3829,7850,1797,1451,  # 6886
+7851,7852,7853,7854,2922,4006,4007,2485,2346, 411,4008,4009,3582,3300,3101,4509,  # 6902
+1561,2664,1452,4010,1375,7855,7856,  47,2959, 316,7857,1406,1591,2923,3156,7858,  # 6918
+1025,2141,3102,3157, 354,2731, 884,2224,4225,2407, 508,3706, 726,3583, 996,2428,  # 6934
+3584, 729,7859, 392,2191,1453,4011,4510,3707,7860,7861,2458,3585,2608,1675,2800,  # 6950
+ 919,2347,2960,2348,1270,4511,4012,  73,7862,7863, 647,7864,3228,2843,2255,1550,  # 6966
+1346,3006,7865,1332, 883,3479,7866,7867,7868,7869,3301,2765,7870,1212, 831,1347,  # 6982
+4226,4512,2326,3830,1863,3053, 720,3831,4513,4514,3832,7871,4227,7872,7873,4515,  # 6998
+7874,7875,1798,4516,3708,2609,4517,3586,1645,2371,7876,7877,2924, 669,2208,2665,  # 7014
+2429,7878,2879,7879,7880,1028,3229,7881,4228,2408,7882,2256,1353,7883,7884,4518,  # 7030
+3158, 518,7885,4013,7886,4229,1960,7887,2142,4230,7888,7889,3007,2349,2350,3833,  # 7046
+ 516,1833,1454,4014,2699,4231,4519,2225,2610,1971,1129,3587,7890,2766,7891,2961,  # 7062
+1422, 577,1470,3008,1524,3373,7892,7893, 432,4232,3054,3480,7894,2586,1455,2508,  # 7078
+2226,1972,1175,7895,1020,2732,4015,3481,4520,7896,2733,7897,1743,1361,3055,3482,  # 7094
+2639,4016,4233,4521,2290, 895, 924,4234,2170, 331,2243,3056, 166,1627,3057,1098,  # 7110
+7898,1232,2880,2227,3374,4522, 657, 403,1196,2372, 542,3709,3375,1600,4235,3483,  # 7126
+7899,4523,2767,3230, 576, 530,1362,7900,4524,2533,2666,3710,4017,7901, 842,3834,  # 7142
+7902,2801,2031,1014,4018, 213,2700,3376, 665, 621,4236,7903,3711,2925,2430,7904,  # 7158
+2431,3302,3588,3377,7905,4237,2534,4238,4525,3589,1682,4239,3484,1380,7906, 724,  # 7174
+2277, 600,1670,7907,1337,1233,4526,3103,2244,7908,1621,4527,7909, 651,4240,7910,  # 7190
+1612,4241,2611,7911,2844,7912,2734,2307,3058,7913, 716,2459,3059, 174,1255,2701,  # 7206
+4019,3590, 548,1320,1398, 728,4020,1574,7914,1890,1197,3060,4021,7915,3061,3062,  # 7222
+3712,3591,3713, 747,7916, 635,4242,4528,7917,7918,7919,4243,7920,7921,4529,7922,  # 7238
+3378,4530,2432, 451,7923,3714,2535,2072,4244,2735,4245,4022,7924,1764,4531,7925,  # 7254
+4246, 350,7926,2278,2390,2486,7927,4247,4023,2245,1434,4024, 488,4532, 458,4248,  # 7270
+4025,3715, 771,1330,2391,3835,2568,3159,2159,2409,1553,2667,3160,4249,7928,2487,  # 7286
+2881,2612,1720,2702,4250,3379,4533,7929,2536,4251,7930,3231,4252,2768,7931,2015,  # 7302
+2736,7932,1155,1017,3716,3836,7933,3303,2308, 201,1864,4253,1430,7934,4026,7935,  # 7318
+7936,7937,7938,7939,4254,1604,7940, 414,1865, 371,2587,4534,4535,3485,2016,3104,  # 7334
+4536,1708, 960,4255, 887, 389,2171,1536,1663,1721,7941,2228,4027,2351,2926,1580,  # 7350
+7942,7943,7944,1744,7945,2537,4537,4538,7946,4539,7947,2073,7948,7949,3592,3380,  # 7366
+2882,4256,7950,4257,2640,3381,2802, 673,2703,2460, 709,3486,4028,3593,4258,7951,  # 7382
+1148, 502, 634,7952,7953,1204,4540,3594,1575,4541,2613,3717,7954,3718,3105, 948,  # 7398
+3232, 121,1745,3837,1110,7955,4259,3063,2509,3009,4029,3719,1151,1771,3838,1488,  # 7414
+4030,1986,7956,2433,3487,7957,7958,2093,7959,4260,3839,1213,1407,2803, 531,2737,  # 7430
+2538,3233,1011,1537,7960,2769,4261,3106,1061,7961,3720,3721,1866,2883,7962,2017,  # 7446
+ 120,4262,4263,2062,3595,3234,2309,3840,2668,3382,1954,4542,7963,7964,3488,1047,  # 7462
+2704,1266,7965,1368,4543,2845, 649,3383,3841,2539,2738,1102,2846,2669,7966,7967,  # 7478
+1999,7968,1111,3596,2962,7969,2488,3842,3597,2804,1854,3384,3722,7970,7971,3385,  # 7494
+2410,2884,3304,3235,3598,7972,2569,7973,3599,2805,4031,1460, 856,7974,3600,7975,  # 7510
+2885,2963,7976,2886,3843,7977,4264, 632,2510, 875,3844,1697,3845,2291,7978,7979,  # 7526
+4544,3010,1239, 580,4545,4265,7980, 914, 936,2074,1190,4032,1039,2123,7981,7982,  # 7542
+7983,3386,1473,7984,1354,4266,3846,7985,2172,3064,4033, 915,3305,4267,4268,3306,  # 7558
+1605,1834,7986,2739, 398,3601,4269,3847,4034, 328,1912,2847,4035,3848,1331,4270,  # 7574
+3011, 937,4271,7987,3602,4036,4037,3387,2160,4546,3388, 524, 742, 538,3065,1012,  # 7590
+7988,7989,3849,2461,7990, 658,1103, 225,3850,7991,7992,4547,7993,4548,7994,3236,  # 7606
+1243,7995,4038, 963,2246,4549,7996,2705,3603,3161,7997,7998,2588,2327,7999,4550,  # 7622
+8000,8001,8002,3489,3307, 957,3389,2540,2032,1930,2927,2462, 870,2018,3604,1746,  # 7638
+2770,2771,2434,2463,8003,3851,8004,3723,3107,3724,3490,3390,3725,8005,1179,3066,  # 7654
+8006,3162,2373,4272,3726,2541,3163,3108,2740,4039,8007,3391,1556,2542,2292, 977,  # 7670
+2887,2033,4040,1205,3392,8008,1765,3393,3164,2124,1271,1689, 714,4551,3491,8009,  # 7686
+2328,3852, 533,4273,3605,2181, 617,8010,2464,3308,3492,2310,8011,8012,3165,8013,  # 7702
+8014,3853,1987, 618, 427,2641,3493,3394,8015,8016,1244,1690,8017,2806,4274,4552,  # 7718
+8018,3494,8019,8020,2279,1576, 473,3606,4275,3395, 972,8021,3607,8022,3067,8023,  # 7734
+8024,4553,4554,8025,3727,4041,4042,8026, 153,4555, 356,8027,1891,2888,4276,2143,  # 7750
+ 408, 803,2352,8028,3854,8029,4277,1646,2570,2511,4556,4557,3855,8030,3856,4278,  # 7766
+8031,2411,3396, 752,8032,8033,1961,2964,8034, 746,3012,2465,8035,4279,3728, 698,  # 7782
+4558,1892,4280,3608,2543,4559,3609,3857,8036,3166,3397,8037,1823,1302,4043,2706,  # 7798
+3858,1973,4281,8038,4282,3167, 823,1303,1288,1236,2848,3495,4044,3398, 774,3859,  # 7814
+8039,1581,4560,1304,2849,3860,4561,8040,2435,2161,1083,3237,4283,4045,4284, 344,  # 7830
+1173, 288,2311, 454,1683,8041,8042,1461,4562,4046,2589,8043,8044,4563, 985, 894,  # 7846
+8045,3399,3168,8046,1913,2928,3729,1988,8047,2110,1974,8048,4047,8049,2571,1194,  # 7862
+ 425,8050,4564,3169,1245,3730,4285,8051,8052,2850,8053, 636,4565,1855,3861, 760,  # 7878
+1799,8054,4286,2209,1508,4566,4048,1893,1684,2293,8055,8056,8057,4287,4288,2210,  # 7894
+ 479,8058,8059, 832,8060,4049,2489,8061,2965,2490,3731, 990,3109, 627,1814,2642,  # 7910
+4289,1582,4290,2125,2111,3496,4567,8062, 799,4291,3170,8063,4568,2112,1737,3013,  # 7926
+1018, 543, 754,4292,3309,1676,4569,4570,4050,8064,1489,8065,3497,8066,2614,2889,  # 7942
+4051,8067,8068,2966,8069,8070,8071,8072,3171,4571,4572,2182,1722,8073,3238,3239,  # 7958
+1842,3610,1715, 481, 365,1975,1856,8074,8075,1962,2491,4573,8076,2126,3611,3240,  # 7974
+ 433,1894,2063,2075,8077, 602,2741,8078,8079,8080,8081,8082,3014,1628,3400,8083,  # 7990
+3172,4574,4052,2890,4575,2512,8084,2544,2772,8085,8086,8087,3310,4576,2891,8088,  # 8006
+4577,8089,2851,4578,4579,1221,2967,4053,2513,8090,8091,8092,1867,1989,8093,8094,  # 8022
+8095,1895,8096,8097,4580,1896,4054, 318,8098,2094,4055,4293,8099,8100, 485,8101,  # 8038
+ 938,3862, 553,2670, 116,8102,3863,3612,8103,3498,2671,2773,3401,3311,2807,8104,  # 8054
+3613,2929,4056,1747,2930,2968,8105,8106, 207,8107,8108,2672,4581,2514,8109,3015,  # 8070
+ 890,3614,3864,8110,1877,3732,3402,8111,2183,2353,3403,1652,8112,8113,8114, 941,  # 8086
+2294, 208,3499,4057,2019, 330,4294,3865,2892,2492,3733,4295,8115,8116,8117,8118,  # 8102
+)
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwprober.py
new file mode 100644
index 0000000000000000000000000000000000000000..35669cc4dd809fa4007ee67c752f1be991135e77
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/euctwprober.py
@@ -0,0 +1,46 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+from .mbcharsetprober import MultiByteCharSetProber
+from .codingstatemachine import CodingStateMachine
+from .chardistribution import EUCTWDistributionAnalysis
+from .mbcssm import EUCTW_SM_MODEL
+
+class EUCTWProber(MultiByteCharSetProber):
+    def __init__(self):
+        super(EUCTWProber, self).__init__()
+        self.coding_sm = CodingStateMachine(EUCTW_SM_MODEL)
+        self.distribution_analyzer = EUCTWDistributionAnalysis()
+        self.reset()
+
+    @property
+    def charset_name(self):
+        return "EUC-TW"
+
+    @property
+    def language(self):
+        return "Taiwan"
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7dbf4c9aa8314816f9bcbe5357146369ee71391
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/__init__.py
@@ -0,0 +1,6 @@
+"""Modules copied from Python 3 standard libraries, for internal use only.
+
+Individual classes and functions are found in d2._backport.misc.  Intended
+usage is to always import things missing from 3.1 from that module: the
+built-in/stdlib objects will be used if found.
+"""
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/misc.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfb318d34f761cde906d8b02dde3f9329688b8c6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/misc.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Backports for individual classes and functions."""
+
+import os
+import sys
+
+__all__ = ['cache_from_source', 'callable', 'fsencode']
+
+
+try:
+    from imp import cache_from_source
+except ImportError:
+    def cache_from_source(py_file, debug=__debug__):
+        ext = debug and 'c' or 'o'
+        return py_file + ext
+
+
+try:
+    callable = callable
+except NameError:
+    from collections import Callable
+
+    def callable(obj):
+        return isinstance(obj, Callable)
+
+
+try:
+    fsencode = os.fsencode
+except AttributeError:
+    def fsencode(filename):
+        if isinstance(filename, bytes):
+            return filename
+        elif isinstance(filename, str):
+            return filename.encode(sys.getfilesystemencoding())
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/shutil.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/shutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..159e49ee8c2aa698aea9a191db91a14716187324
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/shutil.py
@@ -0,0 +1,761 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Utility functions for copying and archiving files and directory trees.
+
+XXX The functions here don't copy the resource fork or other metadata on Mac.
+
+"""
+
+import os
+import sys
+import stat
+from os.path import abspath
+import fnmatch
+import collections
+import errno
+from . import tarfile
+
+try:
+    import bz2
+    _BZ2_SUPPORTED = True
+except ImportError:
+    _BZ2_SUPPORTED = False
+
+try:
+    from pwd import getpwnam
+except ImportError:
+    getpwnam = None
+
+try:
+    from grp import getgrnam
+except ImportError:
+    getgrnam = None
+
+__all__ = ["copyfileobj", "copyfile", "copymode", "copystat", "copy", "copy2",
+           "copytree", "move", "rmtree", "Error", "SpecialFileError",
+           "ExecError", "make_archive", "get_archive_formats",
+           "register_archive_format", "unregister_archive_format",
+           "get_unpack_formats", "register_unpack_format",
+           "unregister_unpack_format", "unpack_archive", "ignore_patterns"]
+
+class Error(EnvironmentError):
+    pass
+
+class SpecialFileError(EnvironmentError):
+    """Raised when trying to do a kind of operation (e.g. copying) which is
+    not supported on a special file (e.g. a named pipe)"""
+
+class ExecError(EnvironmentError):
+    """Raised when a command could not be executed"""
+
+class ReadError(EnvironmentError):
+    """Raised when an archive cannot be read"""
+
+class RegistryError(Exception):
+    """Raised when a registry operation with the archiving
+    and unpacking registries fails"""
+
+
+try:
+    WindowsError
+except NameError:
+    WindowsError = None
+
+def copyfileobj(fsrc, fdst, length=16*1024):
+    """copy data from file-like object fsrc to file-like object fdst"""
+    while 1:
+        buf = fsrc.read(length)
+        if not buf:
+            break
+        fdst.write(buf)
+
+def _samefile(src, dst):
+    # Macintosh, Unix.
+    if hasattr(os.path, 'samefile'):
+        try:
+            return os.path.samefile(src, dst)
+        except OSError:
+            return False
+
+    # All other platforms: check for same pathname.
+    return (os.path.normcase(os.path.abspath(src)) ==
+            os.path.normcase(os.path.abspath(dst)))
+
+def copyfile(src, dst):
+    """Copy data from src to dst"""
+    if _samefile(src, dst):
+        raise Error("`%s` and `%s` are the same file" % (src, dst))
+
+    for fn in [src, dst]:
+        try:
+            st = os.stat(fn)
+        except OSError:
+            # File most likely does not exist
+            pass
+        else:
+            # XXX What about other special files? (sockets, devices...)
+            if stat.S_ISFIFO(st.st_mode):
+                raise SpecialFileError("`%s` is a named pipe" % fn)
+
+    with open(src, 'rb') as fsrc:
+        with open(dst, 'wb') as fdst:
+            copyfileobj(fsrc, fdst)
+
+def copymode(src, dst):
+    """Copy mode bits from src to dst"""
+    if hasattr(os, 'chmod'):
+        st = os.stat(src)
+        mode = stat.S_IMODE(st.st_mode)
+        os.chmod(dst, mode)
+
+def copystat(src, dst):
+    """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
+    st = os.stat(src)
+    mode = stat.S_IMODE(st.st_mode)
+    if hasattr(os, 'utime'):
+        os.utime(dst, (st.st_atime, st.st_mtime))
+    if hasattr(os, 'chmod'):
+        os.chmod(dst, mode)
+    if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
+        try:
+            os.chflags(dst, st.st_flags)
+        except OSError as why:
+            if (not hasattr(errno, 'EOPNOTSUPP') or
+                why.errno != errno.EOPNOTSUPP):
+                raise
+
+def copy(src, dst):
+    """Copy data and mode bits ("cp src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copymode(src, dst)
+
+def copy2(src, dst):
+    """Copy data and all stat info ("cp -p src dst").
+
+    The destination may be a directory.
+
+    """
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+    copyfile(src, dst)
+    copystat(src, dst)
+
+def ignore_patterns(*patterns):
+    """Function that can be used as copytree() ignore parameter.
+
+    Patterns is a sequence of glob-style patterns
+    that are used to exclude files"""
+    def _ignore_patterns(path, names):
+        ignored_names = []
+        for pattern in patterns:
+            ignored_names.extend(fnmatch.filter(names, pattern))
+        return set(ignored_names)
+    return _ignore_patterns
+
+def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
+             ignore_dangling_symlinks=False):
+    """Recursively copy a directory tree.
+
+    The destination directory must not already exist.
+    If exception(s) occur, an Error is raised with a list of reasons.
+
+    If the optional symlinks flag is true, symbolic links in the
+    source tree result in symbolic links in the destination tree; if
+    it is false, the contents of the files pointed to by symbolic
+    links are copied. If the file pointed by the symlink doesn't
+    exist, an exception will be added in the list of errors raised in
+    an Error exception at the end of the copy process.
+
+    You can set the optional ignore_dangling_symlinks flag to true if you
+    want to silence this exception. Notice that this has no effect on
+    platforms that don't support os.symlink.
+
+    The optional ignore argument is a callable. If given, it
+    is called with the `src` parameter, which is the directory
+    being visited by copytree(), and `names` which is the list of
+    `src` contents, as returned by os.listdir():
+
+        callable(src, names) -> ignored_names
+
+    Since copytree() is called recursively, the callable will be
+    called once for each directory that is copied. It returns a
+    list of names relative to the `src` directory that should
+    not be copied.
+
+    The optional copy_function argument is a callable that will be used
+    to copy each file. It will be called with the source path and the
+    destination path as arguments. By default, copy2() is used, but any
+    function that supports the same signature (like copy()) can be used.
+
+    """
+    names = os.listdir(src)
+    if ignore is not None:
+        ignored_names = ignore(src, names)
+    else:
+        ignored_names = set()
+
+    os.makedirs(dst)
+    errors = []
+    for name in names:
+        if name in ignored_names:
+            continue
+        srcname = os.path.join(src, name)
+        dstname = os.path.join(dst, name)
+        try:
+            if os.path.islink(srcname):
+                linkto = os.readlink(srcname)
+                if symlinks:
+                    os.symlink(linkto, dstname)
+                else:
+                    # ignore dangling symlink if the flag is on
+                    if not os.path.exists(linkto) and ignore_dangling_symlinks:
+                        continue
+                    # otherwise let the copy occurs. copy2 will raise an error
+                    copy_function(srcname, dstname)
+            elif os.path.isdir(srcname):
+                copytree(srcname, dstname, symlinks, ignore, copy_function)
+            else:
+                # Will raise a SpecialFileError for unsupported file types
+                copy_function(srcname, dstname)
+        # catch the Error from the recursive copytree so that we can
+        # continue with other files
+        except Error as err:
+            errors.extend(err.args[0])
+        except EnvironmentError as why:
+            errors.append((srcname, dstname, str(why)))
+    try:
+        copystat(src, dst)
+    except OSError as why:
+        if WindowsError is not None and isinstance(why, WindowsError):
+            # Copying file access times may fail on Windows
+            pass
+        else:
+            errors.extend((src, dst, str(why)))
+    if errors:
+        raise Error(errors)
+
+def rmtree(path, ignore_errors=False, onerror=None):
+    """Recursively delete a directory tree.
+
+    If ignore_errors is set, errors are ignored; otherwise, if onerror
+    is set, it is called to handle the error with arguments (func,
+    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
+    path is the argument to that function that caused it to fail; and
+    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
+    is false and onerror is None, an exception is raised.
+
+    """
+    if ignore_errors:
+        def onerror(*args):
+            pass
+    elif onerror is None:
+        def onerror(*args):
+            raise
+    try:
+        if os.path.islink(path):
+            # symlinks to directories are forbidden, see bug #1669
+            raise OSError("Cannot call rmtree on a symbolic link")
+    except OSError:
+        onerror(os.path.islink, path, sys.exc_info())
+        # can't continue even if onerror hook returns
+        return
+    names = []
+    try:
+        names = os.listdir(path)
+    except os.error:
+        onerror(os.listdir, path, sys.exc_info())
+    for name in names:
+        fullname = os.path.join(path, name)
+        try:
+            mode = os.lstat(fullname).st_mode
+        except os.error:
+            mode = 0
+        if stat.S_ISDIR(mode):
+            rmtree(fullname, ignore_errors, onerror)
+        else:
+            try:
+                os.remove(fullname)
+            except os.error:
+                onerror(os.remove, fullname, sys.exc_info())
+    try:
+        os.rmdir(path)
+    except os.error:
+        onerror(os.rmdir, path, sys.exc_info())
+
+
+def _basename(path):
+    # A basename() variant which first strips the trailing slash, if present.
+    # Thus we always get the last component of the path, even for directories.
+    return os.path.basename(path.rstrip(os.path.sep))
+
+def move(src, dst):
+    """Recursively move a file or directory to another location. This is
+    similar to the Unix "mv" command.
+
+    If the destination is a directory or a symlink to a directory, the source
+    is moved inside the directory. The destination path must not already
+    exist.
+
+    If the destination already exists but is not a directory, it may be
+    overwritten depending on os.rename() semantics.
+
+    If the destination is on our current filesystem, then rename() is used.
+    Otherwise, src is copied to the destination and then removed.
+    A lot more could be done here...  A look at a mv.c shows a lot of
+    the issues this implementation glosses over.
+
+    """
+    real_dst = dst
+    if os.path.isdir(dst):
+        if _samefile(src, dst):
+            # We might be on a case insensitive filesystem,
+            # perform the rename anyway.
+            os.rename(src, dst)
+            return
+
+        real_dst = os.path.join(dst, _basename(src))
+        if os.path.exists(real_dst):
+            raise Error("Destination path '%s' already exists" % real_dst)
+    try:
+        os.rename(src, real_dst)
+    except OSError:
+        if os.path.isdir(src):
+            if _destinsrc(src, dst):
+                raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst))
+            copytree(src, real_dst, symlinks=True)
+            rmtree(src)
+        else:
+            copy2(src, real_dst)
+            os.unlink(src)
+
+def _destinsrc(src, dst):
+    src = abspath(src)
+    dst = abspath(dst)
+    if not src.endswith(os.path.sep):
+        src += os.path.sep
+    if not dst.endswith(os.path.sep):
+        dst += os.path.sep
+    return dst.startswith(src)
+
+def _get_gid(name):
+    """Returns a gid, given a group name."""
+    if getgrnam is None or name is None:
+        return None
+    try:
+        result = getgrnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def _get_uid(name):
+    """Returns an uid, given a user name."""
+    if getpwnam is None or name is None:
+        return None
+    try:
+        result = getpwnam(name)
+    except KeyError:
+        result = None
+    if result is not None:
+        return result[2]
+    return None
+
+def _make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
+                  owner=None, group=None, logger=None):
+    """Create a (possibly compressed) tar file from all the files under
+    'base_dir'.
+
+    'compress' must be "gzip" (the default), "bzip2", or None.
+
+    'owner' and 'group' can be used to define an owner and a group for the
+    archive that is being built. If not provided, the current owner and group
+    will be used.
+
+    The output tar file will be named 'base_name' +  ".tar", possibly plus
+    the appropriate compression extension (".gz", or ".bz2").
+
+    Returns the output filename.
+    """
+    tar_compression = {'gzip': 'gz', None: ''}
+    compress_ext = {'gzip': '.gz'}
+
+    if _BZ2_SUPPORTED:
+        tar_compression['bzip2'] = 'bz2'
+        compress_ext['bzip2'] = '.bz2'
+
+    # flags for compression program, each element of list will be an argument
+    if compress is not None and compress not in compress_ext:
+        raise ValueError("bad value for 'compress', or compression format not "
+                         "supported : {0}".format(compress))
+
+    archive_name = base_name + '.tar' + compress_ext.get(compress, '')
+    archive_dir = os.path.dirname(archive_name)
+
+    if not os.path.exists(archive_dir):
+        if logger is not None:
+            logger.info("creating %s", archive_dir)
+        if not dry_run:
+            os.makedirs(archive_dir)
+
+    # creating the tarball
+    if logger is not None:
+        logger.info('Creating tar archive')
+
+    uid = _get_uid(owner)
+    gid = _get_gid(group)
+
+    def _set_uid_gid(tarinfo):
+        if gid is not None:
+            tarinfo.gid = gid
+            tarinfo.gname = group
+        if uid is not None:
+            tarinfo.uid = uid
+            tarinfo.uname = owner
+        return tarinfo
+
+    if not dry_run:
+        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
+        try:
+            tar.add(base_dir, filter=_set_uid_gid)
+        finally:
+            tar.close()
+
+    return archive_name
+
+def _call_external_zip(base_dir, zip_filename, verbose=False, dry_run=False):
+    # XXX see if we want to keep an external call here
+    if verbose:
+        zipoptions = "-r"
+    else:
+        zipoptions = "-rq"
+    from distutils.errors import DistutilsExecError
+    from distutils.spawn import spawn
+    try:
+        spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
+    except DistutilsExecError:
+        # XXX really should distinguish between "couldn't find
+        # external 'zip' command" and "zip failed".
+        raise ExecError("unable to create zip file '%s': "
+            "could neither import the 'zipfile' module nor "
+            "find a standalone zip utility") % zip_filename
+
+def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
+    """Create a zip file from all the files under 'base_dir'.
+
+    The output zip file will be named 'base_name' + ".zip".  Uses either the
+    "zipfile" Python module (if available) or the InfoZIP "zip" utility
+    (if installed and found on the default search path).  If neither tool is
+    available, raises ExecError.  Returns the name of the output zip
+    file.
+    """
+    zip_filename = base_name + ".zip"
+    archive_dir = os.path.dirname(base_name)
+
+    if not os.path.exists(archive_dir):
+        if logger is not None:
+            logger.info("creating %s", archive_dir)
+        if not dry_run:
+            os.makedirs(archive_dir)
+
+    # If zipfile module is not available, try spawning an external 'zip'
+    # command.
+    try:
+        import zipfile
+    except ImportError:
+        zipfile = None
+
+    if zipfile is None:
+        _call_external_zip(base_dir, zip_filename, verbose, dry_run)
+    else:
+        if logger is not None:
+            logger.info("creating '%s' and adding '%s' to it",
+                        zip_filename, base_dir)
+
+        if not dry_run:
+            zip = zipfile.ZipFile(zip_filename, "w",
+                                  compression=zipfile.ZIP_DEFLATED)
+
+            for dirpath, dirnames, filenames in os.walk(base_dir):
+                for name in filenames:
+                    path = os.path.normpath(os.path.join(dirpath, name))
+                    if os.path.isfile(path):
+                        zip.write(path, path)
+                        if logger is not None:
+                            logger.info("adding '%s'", path)
+            zip.close()
+
+    return zip_filename
+
+_ARCHIVE_FORMATS = {
+    'gztar': (_make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
+    'bztar': (_make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
+    'tar':   (_make_tarball, [('compress', None)], "uncompressed tar file"),
+    'zip':   (_make_zipfile, [], "ZIP file"),
+    }
+
+if _BZ2_SUPPORTED:
+    _ARCHIVE_FORMATS['bztar'] = (_make_tarball, [('compress', 'bzip2')],
+                                "bzip2'ed tar-file")
+
+def get_archive_formats():
+    """Returns a list of supported formats for archiving and unarchiving.
+
+    Each element of the returned sequence is a tuple (name, description)
+    """
+    formats = [(name, registry[2]) for name, registry in
+               _ARCHIVE_FORMATS.items()]
+    formats.sort()
+    return formats
+
+def register_archive_format(name, function, extra_args=None, description=''):
+    """Registers an archive format.
+
+    name is the name of the format. function is the callable that will be
+    used to create archives. If provided, extra_args is a sequence of
+    (name, value) tuples that will be passed as arguments to the callable.
+    description can be provided to describe the format, and will be returned
+    by the get_archive_formats() function.
+    """
+    if extra_args is None:
+        extra_args = []
+    if not isinstance(function, collections.Callable):
+        raise TypeError('The %s object is not callable' % function)
+    if not isinstance(extra_args, (tuple, list)):
+        raise TypeError('extra_args needs to be a sequence')
+    for element in extra_args:
+        if not isinstance(element, (tuple, list)) or len(element) !=2:
+            raise TypeError('extra_args elements are : (arg_name, value)')
+
+    _ARCHIVE_FORMATS[name] = (function, extra_args, description)
+
+def unregister_archive_format(name):
+    del _ARCHIVE_FORMATS[name]
+
+def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
+                 dry_run=0, owner=None, group=None, logger=None):
+    """Create an archive file (eg. zip or tar).
+
+    'base_name' is the name of the file to create, minus any format-specific
+    extension; 'format' is the archive format: one of "zip", "tar", "bztar"
+    or "gztar".
+
+    'root_dir' is a directory that will be the root directory of the
+    archive; ie. we typically chdir into 'root_dir' before creating the
+    archive.  'base_dir' is the directory where we start archiving from;
+    ie. 'base_dir' will be the common prefix of all files and
+    directories in the archive.  'root_dir' and 'base_dir' both default
+    to the current directory.  Returns the name of the archive file.
+
+    'owner' and 'group' are used when creating a tar archive. By default,
+    uses the current owner and group.
+    """
+    save_cwd = os.getcwd()
+    if root_dir is not None:
+        if logger is not None:
+            logger.debug("changing into '%s'", root_dir)
+        base_name = os.path.abspath(base_name)
+        if not dry_run:
+            os.chdir(root_dir)
+
+    if base_dir is None:
+        base_dir = os.curdir
+
+    kwargs = {'dry_run': dry_run, 'logger': logger}
+
+    try:
+        format_info = _ARCHIVE_FORMATS[format]
+    except KeyError:
+        raise ValueError("unknown archive format '%s'" % format)
+
+    func = format_info[0]
+    for arg, val in format_info[1]:
+        kwargs[arg] = val
+
+    if format != 'zip':
+        kwargs['owner'] = owner
+        kwargs['group'] = group
+
+    try:
+        filename = func(base_name, base_dir, **kwargs)
+    finally:
+        if root_dir is not None:
+            if logger is not None:
+                logger.debug("changing back to '%s'", save_cwd)
+            os.chdir(save_cwd)
+
+    return filename
+
+
+def get_unpack_formats():
+    """Returns a list of supported formats for unpacking.
+
+    Each element of the returned sequence is a tuple
+    (name, extensions, description)
+    """
+    formats = [(name, info[0], info[3]) for name, info in
+               _UNPACK_FORMATS.items()]
+    formats.sort()
+    return formats
+
+def _check_unpack_options(extensions, function, extra_args):
+    """Checks what gets registered as an unpacker."""
+    # first make sure no other unpacker is registered for this extension
+    existing_extensions = {}
+    for name, info in _UNPACK_FORMATS.items():
+        for ext in info[0]:
+            existing_extensions[ext] = name
+
+    for extension in extensions:
+        if extension in existing_extensions:
+            msg = '%s is already registered for "%s"'
+            raise RegistryError(msg % (extension,
+                                       existing_extensions[extension]))
+
+    if not isinstance(function, collections.Callable):
+        raise TypeError('The registered function must be a callable')
+
+
+def register_unpack_format(name, extensions, function, extra_args=None,
+                           description=''):
+    """Registers an unpack format.
+
+    `name` is the name of the format. `extensions` is a list of extensions
+    corresponding to the format.
+
+    `function` is the callable that will be
+    used to unpack archives. The callable will receive archives to unpack.
+    If it's unable to handle an archive, it needs to raise a ReadError
+    exception.
+
+    If provided, `extra_args` is a sequence of
+    (name, value) tuples that will be passed as arguments to the callable.
+    description can be provided to describe the format, and will be returned
+    by the get_unpack_formats() function.
+    """
+    if extra_args is None:
+        extra_args = []
+    _check_unpack_options(extensions, function, extra_args)
+    _UNPACK_FORMATS[name] = extensions, function, extra_args, description
+
+def unregister_unpack_format(name):
+    """Removes the pack format from the registry."""
+    del _UNPACK_FORMATS[name]
+
+def _ensure_directory(path):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    if not os.path.isdir(dirname):
+        os.makedirs(dirname)
+
+def _unpack_zipfile(filename, extract_dir):
+    """Unpack zip `filename` to `extract_dir`
+    """
+    try:
+        import zipfile
+    except ImportError:
+        raise ReadError('zlib not supported, cannot unpack this archive.')
+
+    if not zipfile.is_zipfile(filename):
+        raise ReadError("%s is not a zip file" % filename)
+
+    zip = zipfile.ZipFile(filename)
+    try:
+        for info in zip.infolist():
+            name = info.filename
+
+            # don't extract absolute paths or ones with .. in them
+            if name.startswith('/') or '..' in name:
+                continue
+
+            target = os.path.join(extract_dir, *name.split('/'))
+            if not target:
+                continue
+
+            _ensure_directory(target)
+            if not name.endswith('/'):
+                # file
+                data = zip.read(info.filename)
+                f = open(target, 'wb')
+                try:
+                    f.write(data)
+                finally:
+                    f.close()
+                    del data
+    finally:
+        zip.close()
+
+def _unpack_tarfile(filename, extract_dir):
+    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
+    """
+    try:
+        tarobj = tarfile.open(filename)
+    except tarfile.TarError:
+        raise ReadError(
+            "%s is not a compressed or uncompressed tar file" % filename)
+    try:
+        tarobj.extractall(extract_dir)
+    finally:
+        tarobj.close()
+
+_UNPACK_FORMATS = {
+    'gztar': (['.tar.gz', '.tgz'], _unpack_tarfile, [], "gzip'ed tar-file"),
+    'tar':   (['.tar'], _unpack_tarfile, [], "uncompressed tar file"),
+    'zip':   (['.zip'], _unpack_zipfile, [], "ZIP file")
+    }
+
+if _BZ2_SUPPORTED:
+    _UNPACK_FORMATS['bztar'] = (['.bz2'], _unpack_tarfile, [],
+                                "bzip2'ed tar-file")
+
+def _find_unpack_format(filename):
+    for name, info in _UNPACK_FORMATS.items():
+        for extension in info[0]:
+            if filename.endswith(extension):
+                return name
+    return None
+
+def unpack_archive(filename, extract_dir=None, format=None):
+    """Unpack an archive.
+
+    `filename` is the name of the archive.
+
+    `extract_dir` is the name of the target directory, where the archive
+    is unpacked. If not provided, the current working directory is used.
+
+    `format` is the archive format: one of "zip", "tar", or "gztar". Or any
+    other registered format. If not provided, unpack_archive will use the
+    filename extension and see if an unpacker was registered for that
+    extension.
+
+    In case none is found, a ValueError is raised.
+    """
+    if extract_dir is None:
+        extract_dir = os.getcwd()
+
+    if format is not None:
+        try:
+            format_info = _UNPACK_FORMATS[format]
+        except KeyError:
+            raise ValueError("Unknown unpack format '{0}'".format(format))
+
+        func = format_info[1]
+        func(filename, extract_dir, **dict(format_info[2]))
+    else:
+        # we need to look at the registered unpackers supported extensions
+        format = _find_unpack_format(filename)
+        if format is None:
+            raise ReadError("Unknown archive format '{0}'".format(filename))
+
+        func = _UNPACK_FORMATS[format][1]
+        kwargs = dict(_UNPACK_FORMATS[format][2])
+        func(filename, extract_dir, **kwargs)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..1746bd01c1ad915b728ab58b4668c82b2bd578e1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.cfg
@@ -0,0 +1,84 @@
+[posix_prefix]
+# Configuration directories.  Some of these come straight out of the
+# configure script.  They are for implementing the other variables, not to
+# be used directly in [resource_locations].
+confdir = /etc
+datadir = /usr/share
+libdir = /usr/lib
+statedir = /var
+# User resource directory
+local = ~/.local/{distribution.name}
+
+stdlib = {base}/lib/python{py_version_short}
+platstdlib = {platbase}/lib/python{py_version_short}
+purelib = {base}/lib/python{py_version_short}/site-packages
+platlib = {platbase}/lib/python{py_version_short}/site-packages
+include = {base}/include/python{py_version_short}{abiflags}
+platinclude = {platbase}/include/python{py_version_short}{abiflags}
+data = {base}
+
+[posix_home]
+stdlib = {base}/lib/python
+platstdlib = {base}/lib/python
+purelib = {base}/lib/python
+platlib = {base}/lib/python
+include = {base}/include/python
+platinclude = {base}/include/python
+scripts = {base}/bin
+data = {base}
+
+[nt]
+stdlib = {base}/Lib
+platstdlib = {base}/Lib
+purelib = {base}/Lib/site-packages
+platlib = {base}/Lib/site-packages
+include = {base}/Include
+platinclude = {base}/Include
+scripts = {base}/Scripts
+data = {base}
+
+[os2]
+stdlib = {base}/Lib
+platstdlib = {base}/Lib
+purelib = {base}/Lib/site-packages
+platlib = {base}/Lib/site-packages
+include = {base}/Include
+platinclude = {base}/Include
+scripts = {base}/Scripts
+data = {base}
+
+[os2_home]
+stdlib = {userbase}/lib/python{py_version_short}
+platstdlib = {userbase}/lib/python{py_version_short}
+purelib = {userbase}/lib/python{py_version_short}/site-packages
+platlib = {userbase}/lib/python{py_version_short}/site-packages
+include = {userbase}/include/python{py_version_short}
+scripts = {userbase}/bin
+data = {userbase}
+
+[nt_user]
+stdlib = {userbase}/Python{py_version_nodot}
+platstdlib = {userbase}/Python{py_version_nodot}
+purelib = {userbase}/Python{py_version_nodot}/site-packages
+platlib = {userbase}/Python{py_version_nodot}/site-packages
+include = {userbase}/Python{py_version_nodot}/Include
+scripts = {userbase}/Scripts
+data = {userbase}
+
+[posix_user]
+stdlib = {userbase}/lib/python{py_version_short}
+platstdlib = {userbase}/lib/python{py_version_short}
+purelib = {userbase}/lib/python{py_version_short}/site-packages
+platlib = {userbase}/lib/python{py_version_short}/site-packages
+include = {userbase}/include/python{py_version_short}
+scripts = {userbase}/bin
+data = {userbase}
+
+[osx_framework_user]
+stdlib = {userbase}/lib/python
+platstdlib = {userbase}/lib/python
+purelib = {userbase}/lib/python/site-packages
+platlib = {userbase}/lib/python/site-packages
+include = {userbase}/include
+scripts = {userbase}/bin
+data = {userbase}
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..1df3aba144c874384f6768427cd38d26028e27dc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/sysconfig.py
@@ -0,0 +1,788 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Access to Python's configuration information."""
+
+import codecs
+import os
+import re
+import sys
+from os.path import pardir, realpath
+try:
+    import configparser
+except ImportError:
+    import ConfigParser as configparser
+
+
+__all__ = [
+    'get_config_h_filename',
+    'get_config_var',
+    'get_config_vars',
+    'get_makefile_filename',
+    'get_path',
+    'get_path_names',
+    'get_paths',
+    'get_platform',
+    'get_python_version',
+    'get_scheme_names',
+    'parse_config_h',
+]
+
+
+def _safe_realpath(path):
+    try:
+        return realpath(path)
+    except OSError:
+        return path
+
+
+if sys.executable:
+    _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
+else:
+    # sys.executable can be empty if argv[0] has been changed and Python is
+    # unable to retrieve the real program name
+    _PROJECT_BASE = _safe_realpath(os.getcwd())
+
+if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
+# PC/VS7.1
+if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
+# PC/AMD64
+if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
+    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
+
+
+def is_python_build():
+    for fn in ("Setup.dist", "Setup.local"):
+        if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
+            return True
+    return False
+
+_PYTHON_BUILD = is_python_build()
+
+_cfg_read = False
+
+def _ensure_cfg_read():
+    global _cfg_read
+    if not _cfg_read:
+        from ..resources import finder
+        backport_package = __name__.rsplit('.', 1)[0]
+        _finder = finder(backport_package)
+        _cfgfile = _finder.find('sysconfig.cfg')
+        assert _cfgfile, 'sysconfig.cfg exists'
+        with _cfgfile.as_stream() as s:
+            _SCHEMES.readfp(s)
+        if _PYTHON_BUILD:
+            for scheme in ('posix_prefix', 'posix_home'):
+                _SCHEMES.set(scheme, 'include', '{srcdir}/Include')
+                _SCHEMES.set(scheme, 'platinclude', '{projectbase}/.')
+
+        _cfg_read = True
+
+
+_SCHEMES = configparser.RawConfigParser()
+_VAR_REPL = re.compile(r'\{([^{]*?)\}')
+
+def _expand_globals(config):
+    _ensure_cfg_read()
+    if config.has_section('globals'):
+        globals = config.items('globals')
+    else:
+        globals = tuple()
+
+    sections = config.sections()
+    for section in sections:
+        if section == 'globals':
+            continue
+        for option, value in globals:
+            if config.has_option(section, option):
+                continue
+            config.set(section, option, value)
+    config.remove_section('globals')
+
+    # now expanding local variables defined in the cfg file
+    #
+    for section in config.sections():
+        variables = dict(config.items(section))
+
+        def _replacer(matchobj):
+            name = matchobj.group(1)
+            if name in variables:
+                return variables[name]
+            return matchobj.group(0)
+
+        for option, value in config.items(section):
+            config.set(section, option, _VAR_REPL.sub(_replacer, value))
+
+#_expand_globals(_SCHEMES)
+
+ # FIXME don't rely on sys.version here, its format is an implementation detail
+ # of CPython, use sys.version_info or sys.hexversion
+_PY_VERSION = sys.version.split()[0]
+_PY_VERSION_SHORT = sys.version[:3]
+_PY_VERSION_SHORT_NO_DOT = _PY_VERSION[0] + _PY_VERSION[2]
+_PREFIX = os.path.normpath(sys.prefix)
+_EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
+_CONFIG_VARS = None
+_USER_BASE = None
+
+
+def _subst_vars(path, local_vars):
+    """In the string `path`, replace tokens like {some.thing} with the
+    corresponding value from the map `local_vars`.
+
+    If there is no corresponding value, leave the token unchanged.
+    """
+    def _replacer(matchobj):
+        name = matchobj.group(1)
+        if name in local_vars:
+            return local_vars[name]
+        elif name in os.environ:
+            return os.environ[name]
+        return matchobj.group(0)
+    return _VAR_REPL.sub(_replacer, path)
+
+
+def _extend_dict(target_dict, other_dict):
+    target_keys = target_dict.keys()
+    for key, value in other_dict.items():
+        if key in target_keys:
+            continue
+        target_dict[key] = value
+
+
+def _expand_vars(scheme, vars):
+    res = {}
+    if vars is None:
+        vars = {}
+    _extend_dict(vars, get_config_vars())
+
+    for key, value in _SCHEMES.items(scheme):
+        if os.name in ('posix', 'nt'):
+            value = os.path.expanduser(value)
+        res[key] = os.path.normpath(_subst_vars(value, vars))
+    return res
+
+
+def format_value(value, vars):
+    def _replacer(matchobj):
+        name = matchobj.group(1)
+        if name in vars:
+            return vars[name]
+        return matchobj.group(0)
+    return _VAR_REPL.sub(_replacer, value)
+
+
+def _get_default_scheme():
+    if os.name == 'posix':
+        # the default scheme for posix is posix_prefix
+        return 'posix_prefix'
+    return os.name
+
+
+def _getuserbase():
+    env_base = os.environ.get("PYTHONUSERBASE", None)
+
+    def joinuser(*args):
+        return os.path.expanduser(os.path.join(*args))
+
+    # what about 'os2emx', 'riscos' ?
+    if os.name == "nt":
+        base = os.environ.get("APPDATA") or "~"
+        if env_base:
+            return env_base
+        else:
+            return joinuser(base, "Python")
+
+    if sys.platform == "darwin":
+        framework = get_config_var("PYTHONFRAMEWORK")
+        if framework:
+            if env_base:
+                return env_base
+            else:
+                return joinuser("~", "Library", framework, "%d.%d" %
+                                sys.version_info[:2])
+
+    if env_base:
+        return env_base
+    else:
+        return joinuser("~", ".local")
+
+
+def _parse_makefile(filename, vars=None):
+    """Parse a Makefile-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    # Regexes needed for parsing Makefile (and similar syntaxes,
+    # like old-style Setup files).
+    _variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
+    _findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
+    _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
+
+    if vars is None:
+        vars = {}
+    done = {}
+    notdone = {}
+
+    with codecs.open(filename, encoding='utf-8', errors="surrogateescape") as f:
+        lines = f.readlines()
+
+    for line in lines:
+        if line.startswith('#') or line.strip() == '':
+            continue
+        m = _variable_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            v = v.strip()
+            # `$$' is a literal `$' in make
+            tmpv = v.replace('$$', '')
+
+            if "$" in tmpv:
+                notdone[n] = v
+            else:
+                try:
+                    v = int(v)
+                except ValueError:
+                    # insert literal `$'
+                    done[n] = v.replace('$$', '$')
+                else:
+                    done[n] = v
+
+    # do variable interpolation here
+    variables = list(notdone.keys())
+
+    # Variables with a 'PY_' prefix in the makefile. These need to
+    # be made available without that prefix through sysconfig.
+    # Special care is needed to ensure that variable expansion works, even
+    # if the expansion uses the name without a prefix.
+    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
+
+    while len(variables) > 0:
+        for name in tuple(variables):
+            value = notdone[name]
+            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
+            if m is not None:
+                n = m.group(1)
+                found = True
+                if n in done:
+                    item = str(done[n])
+                elif n in notdone:
+                    # get it on a subsequent round
+                    found = False
+                elif n in os.environ:
+                    # do it like make: fall back to environment
+                    item = os.environ[n]
+
+                elif n in renamed_variables:
+                    if (name.startswith('PY_') and
+                        name[3:] in renamed_variables):
+                        item = ""
+
+                    elif 'PY_' + n in notdone:
+                        found = False
+
+                    else:
+                        item = str(done['PY_' + n])
+
+                else:
+                    done[n] = item = ""
+
+                if found:
+                    after = value[m.end():]
+                    value = value[:m.start()] + item + after
+                    if "$" in after:
+                        notdone[name] = value
+                    else:
+                        try:
+                            value = int(value)
+                        except ValueError:
+                            done[name] = value.strip()
+                        else:
+                            done[name] = value
+                        variables.remove(name)
+
+                        if (name.startswith('PY_') and
+                            name[3:] in renamed_variables):
+
+                            name = name[3:]
+                            if name not in done:
+                                done[name] = value
+
+            else:
+                # bogus variable reference (e.g. "prefix=$/opt/python");
+                # just drop it since we can't deal
+                done[name] = value
+                variables.remove(name)
+
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
+
+    # save the results in the global dictionary
+    vars.update(done)
+    return vars
+
+
+def get_makefile_filename():
+    """Return the path of the Makefile."""
+    if _PYTHON_BUILD:
+        return os.path.join(_PROJECT_BASE, "Makefile")
+    if hasattr(sys, 'abiflags'):
+        config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
+    else:
+        config_dir_name = 'config'
+    return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
+
+
+def _init_posix(vars):
+    """Initialize the module as appropriate for POSIX systems."""
+    # load the installed Makefile:
+    makefile = get_makefile_filename()
+    try:
+        _parse_makefile(makefile, vars)
+    except IOError as e:
+        msg = "invalid Python installation: unable to open %s" % makefile
+        if hasattr(e, "strerror"):
+            msg = msg + " (%s)" % e.strerror
+        raise IOError(msg)
+    # load the installed pyconfig.h:
+    config_h = get_config_h_filename()
+    try:
+        with open(config_h) as f:
+            parse_config_h(f, vars)
+    except IOError as e:
+        msg = "invalid Python installation: unable to open %s" % config_h
+        if hasattr(e, "strerror"):
+            msg = msg + " (%s)" % e.strerror
+        raise IOError(msg)
+    # On AIX, there are wrong paths to the linker scripts in the Makefile
+    # -- these paths are relative to the Python source, but when installed
+    # the scripts are in another directory.
+    if _PYTHON_BUILD:
+        vars['LDSHARED'] = vars['BLDSHARED']
+
+
+def _init_non_posix(vars):
+    """Initialize the module as appropriate for NT"""
+    # set basic install directories
+    vars['LIBDEST'] = get_path('stdlib')
+    vars['BINLIBDEST'] = get_path('platstdlib')
+    vars['INCLUDEPY'] = get_path('include')
+    vars['SO'] = '.pyd'
+    vars['EXE'] = '.exe'
+    vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
+    vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
+
+#
+# public APIs
+#
+
+
+def parse_config_h(fp, vars=None):
+    """Parse a config.h-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    if vars is None:
+        vars = {}
+    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
+    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
+
+    while True:
+        line = fp.readline()
+        if not line:
+            break
+        m = define_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            try:
+                v = int(v)
+            except ValueError:
+                pass
+            vars[n] = v
+        else:
+            m = undef_rx.match(line)
+            if m:
+                vars[m.group(1)] = 0
+    return vars
+
+
+def get_config_h_filename():
+    """Return the path of pyconfig.h."""
+    if _PYTHON_BUILD:
+        if os.name == "nt":
+            inc_dir = os.path.join(_PROJECT_BASE, "PC")
+        else:
+            inc_dir = _PROJECT_BASE
+    else:
+        inc_dir = get_path('platinclude')
+    return os.path.join(inc_dir, 'pyconfig.h')
+
+
+def get_scheme_names():
+    """Return a tuple containing the schemes names."""
+    return tuple(sorted(_SCHEMES.sections()))
+
+
+def get_path_names():
+    """Return a tuple containing the paths names."""
+    # xxx see if we want a static list
+    return _SCHEMES.options('posix_prefix')
+
+
+def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
+    """Return a mapping containing an install scheme.
+
+    ``scheme`` is the install scheme name. If not provided, it will
+    return the default scheme for the current platform.
+    """
+    _ensure_cfg_read()
+    if expand:
+        return _expand_vars(scheme, vars)
+    else:
+        return dict(_SCHEMES.items(scheme))
+
+
+def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
+    """Return a path corresponding to the scheme.
+
+    ``scheme`` is the install scheme name.
+    """
+    return get_paths(scheme, vars, expand)[name]
+
+
+def get_config_vars(*args):
+    """With no arguments, return a dictionary of all configuration
+    variables relevant for the current platform.
+
+    On Unix, this means every variable defined in Python's installed Makefile;
+    On Windows and Mac OS it's a much smaller set.
+
+    With arguments, return a list of values that result from looking up
+    each argument in the configuration variable dictionary.
+    """
+    global _CONFIG_VARS
+    if _CONFIG_VARS is None:
+        _CONFIG_VARS = {}
+        # Normalized versions of prefix and exec_prefix are handy to have;
+        # in fact, these are the standard versions used most places in the
+        # distutils2 module.
+        _CONFIG_VARS['prefix'] = _PREFIX
+        _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
+        _CONFIG_VARS['py_version'] = _PY_VERSION
+        _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
+        _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
+        _CONFIG_VARS['base'] = _PREFIX
+        _CONFIG_VARS['platbase'] = _EXEC_PREFIX
+        _CONFIG_VARS['projectbase'] = _PROJECT_BASE
+        try:
+            _CONFIG_VARS['abiflags'] = sys.abiflags
+        except AttributeError:
+            # sys.abiflags may not be defined on all platforms.
+            _CONFIG_VARS['abiflags'] = ''
+
+        if os.name in ('nt', 'os2'):
+            _init_non_posix(_CONFIG_VARS)
+        if os.name == 'posix':
+            _init_posix(_CONFIG_VARS)
+        # Setting 'userbase' is done below the call to the
+        # init function to enable using 'get_config_var' in
+        # the init-function.
+        if sys.version >= '2.6':
+            _CONFIG_VARS['userbase'] = _getuserbase()
+
+        if 'srcdir' not in _CONFIG_VARS:
+            _CONFIG_VARS['srcdir'] = _PROJECT_BASE
+        else:
+            _CONFIG_VARS['srcdir'] = _safe_realpath(_CONFIG_VARS['srcdir'])
+
+        # Convert srcdir into an absolute path if it appears necessary.
+        # Normally it is relative to the build directory.  However, during
+        # testing, for example, we might be running a non-installed python
+        # from a different directory.
+        if _PYTHON_BUILD and os.name == "posix":
+            base = _PROJECT_BASE
+            try:
+                cwd = os.getcwd()
+            except OSError:
+                cwd = None
+            if (not os.path.isabs(_CONFIG_VARS['srcdir']) and
+                base != cwd):
+                # srcdir is relative and we are not in the same directory
+                # as the executable. Assume executable is in the build
+                # directory and make srcdir absolute.
+                srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
+                _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)
+
+        if sys.platform == 'darwin':
+            kernel_version = os.uname()[2]  # Kernel version (8.4.3)
+            major_version = int(kernel_version.split('.')[0])
+
+            if major_version < 8:
+                # On Mac OS X before 10.4, check if -arch and -isysroot
+                # are in CFLAGS or LDFLAGS and remove them if they are.
+                # This is needed when building extensions on a 10.3 system
+                # using a universal build of python.
+                for key in ('LDFLAGS', 'BASECFLAGS',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+                    flags = _CONFIG_VARS[key]
+                    flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
+                    flags = re.sub('-isysroot [^ \t]*', ' ', flags)
+                    _CONFIG_VARS[key] = flags
+            else:
+                # Allow the user to override the architecture flags using
+                # an environment variable.
+                # NOTE: This name was introduced by Apple in OSX 10.5 and
+                # is used by several scripting languages distributed with
+                # that OS release.
+                if 'ARCHFLAGS' in os.environ:
+                    arch = os.environ['ARCHFLAGS']
+                    for key in ('LDFLAGS', 'BASECFLAGS',
+                        # a number of derived variables. These need to be
+                        # patched up as well.
+                        'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+
+                        flags = _CONFIG_VARS[key]
+                        flags = re.sub(r'-arch\s+\w+\s', ' ', flags)
+                        flags = flags + ' ' + arch
+                        _CONFIG_VARS[key] = flags
+
+                # If we're on OSX 10.5 or later and the user tries to
+                # compiles an extension using an SDK that is not present
+                # on the current machine it is better to not use an SDK
+                # than to fail.
+                #
+                # The major usecase for this is users using a Python.org
+                # binary installer  on OSX 10.6: that installer uses
+                # the 10.4u SDK, but that SDK is not installed by default
+                # when you install Xcode.
+                #
+                CFLAGS = _CONFIG_VARS.get('CFLAGS', '')
+                m = re.search(r'-isysroot\s+(\S+)', CFLAGS)
+                if m is not None:
+                    sdk = m.group(1)
+                    if not os.path.exists(sdk):
+                        for key in ('LDFLAGS', 'BASECFLAGS',
+                             # a number of derived variables. These need to be
+                             # patched up as well.
+                            'CFLAGS', 'PY_CFLAGS', 'BLDSHARED'):
+
+                            flags = _CONFIG_VARS[key]
+                            flags = re.sub(r'-isysroot\s+\S+(\s|$)', ' ', flags)
+                            _CONFIG_VARS[key] = flags
+
+    if args:
+        vals = []
+        for name in args:
+            vals.append(_CONFIG_VARS.get(name))
+        return vals
+    else:
+        return _CONFIG_VARS
+
+
+def get_config_var(name):
+    """Return the value of a single variable using the dictionary returned by
+    'get_config_vars()'.
+
+    Equivalent to get_config_vars().get(name)
+    """
+    return get_config_vars().get(name)
+
+
+def get_platform():
+    """Return a string that identifies the current platform.
+
+    This is used mainly to distinguish platform-specific build directories and
+    platform-specific built distributions.  Typically includes the OS name
+    and version and the architecture (as supplied by 'os.uname()'),
+    although the exact information included depends on the OS; eg. for IRIX
+    the architecture isn't particularly important (IRIX only runs on SGI
+    hardware), but for Linux the kernel version isn't particularly
+    important.
+
+    Examples of returned values:
+       linux-i586
+       linux-alpha (?)
+       solaris-2.6-sun4u
+       irix-5.3
+       irix64-6.2
+
+    Windows will return one of:
+       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
+       win-ia64 (64bit Windows on Itanium)
+       win32 (all others - specifically, sys.platform is returned)
+
+    For other non-POSIX platforms, currently just returns 'sys.platform'.
+    """
+    if os.name == 'nt':
+        # sniff sys.version for architecture.
+        prefix = " bit ("
+        i = sys.version.find(prefix)
+        if i == -1:
+            return sys.platform
+        j = sys.version.find(")", i)
+        look = sys.version[i+len(prefix):j].lower()
+        if look == 'amd64':
+            return 'win-amd64'
+        if look == 'itanium':
+            return 'win-ia64'
+        return sys.platform
+
+    if os.name != "posix" or not hasattr(os, 'uname'):
+        # XXX what about the architecture? NT is Intel or Alpha,
+        # Mac OS is M68k or PPC, etc.
+        return sys.platform
+
+    # Try to distinguish various flavours of Unix
+    osname, host, release, version, machine = os.uname()
+
+    # Convert the OS name to lowercase, remove '/' characters
+    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
+    osname = osname.lower().replace('/', '')
+    machine = machine.replace(' ', '_')
+    machine = machine.replace('/', '-')
+
+    if osname[:5] == "linux":
+        # At least on Linux/Intel, 'machine' is the processor --
+        # i386, etc.
+        # XXX what about Alpha, SPARC, etc?
+        return  "%s-%s" % (osname, machine)
+    elif osname[:5] == "sunos":
+        if release[0] >= "5":           # SunOS 5 == Solaris 2
+            osname = "solaris"
+            release = "%d.%s" % (int(release[0]) - 3, release[2:])
+        # fall through to standard osname-release-machine representation
+    elif osname[:4] == "irix":              # could be "irix64"!
+        return "%s-%s" % (osname, release)
+    elif osname[:3] == "aix":
+        return "%s-%s.%s" % (osname, version, release)
+    elif osname[:6] == "cygwin":
+        osname = "cygwin"
+        rel_re = re.compile(r'[\d.]+')
+        m = rel_re.match(release)
+        if m:
+            release = m.group()
+    elif osname[:6] == "darwin":
+        #
+        # For our purposes, we'll assume that the system version from
+        # distutils' perspective is what MACOSX_DEPLOYMENT_TARGET is set
+        # to. This makes the compatibility story a bit more sane because the
+        # machine is going to compile and link as if it were
+        # MACOSX_DEPLOYMENT_TARGET.
+        cfgvars = get_config_vars()
+        macver = cfgvars.get('MACOSX_DEPLOYMENT_TARGET')
+
+        if True:
+            # Always calculate the release of the running machine,
+            # needed to determine if we can build fat binaries or not.
+
+            macrelease = macver
+            # Get the system version. Reading this plist is a documented
+            # way to get the system version (see the documentation for
+            # the Gestalt Manager)
+            try:
+                f = open('/System/Library/CoreServices/SystemVersion.plist')
+            except IOError:
+                # We're on a plain darwin box, fall back to the default
+                # behaviour.
+                pass
+            else:
+                try:
+                    m = re.search(r'<key>ProductUserVisibleVersion</key>\s*'
+                                  r'<string>(.*?)</string>', f.read())
+                finally:
+                    f.close()
+                if m is not None:
+                    macrelease = '.'.join(m.group(1).split('.')[:2])
+                # else: fall back to the default behaviour
+
+        if not macver:
+            macver = macrelease
+
+        if macver:
+            release = macver
+            osname = "macosx"
+
+            if ((macrelease + '.') >= '10.4.' and
+                '-arch' in get_config_vars().get('CFLAGS', '').strip()):
+                # The universal build will build fat binaries, but not on
+                # systems before 10.4
+                #
+                # Try to detect 4-way universal builds, those have machine-type
+                # 'universal' instead of 'fat'.
+
+                machine = 'fat'
+                cflags = get_config_vars().get('CFLAGS')
+
+                archs = re.findall(r'-arch\s+(\S+)', cflags)
+                archs = tuple(sorted(set(archs)))
+
+                if len(archs) == 1:
+                    machine = archs[0]
+                elif archs == ('i386', 'ppc'):
+                    machine = 'fat'
+                elif archs == ('i386', 'x86_64'):
+                    machine = 'intel'
+                elif archs == ('i386', 'ppc', 'x86_64'):
+                    machine = 'fat3'
+                elif archs == ('ppc64', 'x86_64'):
+                    machine = 'fat64'
+                elif archs == ('i386', 'ppc', 'ppc64', 'x86_64'):
+                    machine = 'universal'
+                else:
+                    raise ValueError(
+                       "Don't know machine value for archs=%r" % (archs,))
+
+            elif machine == 'i386':
+                # On OSX the machine type returned by uname is always the
+                # 32-bit variant, even if the executable architecture is
+                # the 64-bit variant
+                if sys.maxsize >= 2**32:
+                    machine = 'x86_64'
+
+            elif machine in ('PowerPC', 'Power_Macintosh'):
+                # Pick a sane name for the PPC architecture.
+                # See 'i386' case
+                if sys.maxsize >= 2**32:
+                    machine = 'ppc64'
+                else:
+                    machine = 'ppc'
+
+    return "%s-%s-%s" % (osname, release, machine)
+
+
+def get_python_version():
+    return _PY_VERSION_SHORT
+
+
+def _print_dict(title, data):
+    for index, (key, value) in enumerate(sorted(data.items())):
+        if index == 0:
+            print('%s: ' % (title))
+        print('\t%s = "%s"' % (key, value))
+
+
+def _main():
+    """Display all information sysconfig detains."""
+    print('Platform: "%s"' % get_platform())
+    print('Python version: "%s"' % get_python_version())
+    print('Current installation scheme: "%s"' % _get_default_scheme())
+    print()
+    _print_dict('Paths', get_paths())
+    print()
+    _print_dict('Variables', get_config_vars())
+
+
+if __name__ == '__main__':
+    _main()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/tarfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/tarfile.py
new file mode 100644
index 0000000000000000000000000000000000000000..d66d8566374be661085213468bce338c6a747702
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/_backport/tarfile.py
@@ -0,0 +1,2607 @@
+#-------------------------------------------------------------------
+# tarfile.py
+#-------------------------------------------------------------------
+# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>
+# All rights reserved.
+#
+# 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.
+#
+from __future__ import print_function
+
+"""Read from and write to tar format archives.
+"""
+
+__version__ = "$Revision$"
+
+version     = "0.9.0"
+__author__  = "Lars Gust\u00e4bel (lars@gustaebel.de)"
+__date__    = "$Date: 2011-02-25 17:42:01 +0200 (Fri, 25 Feb 2011) $"
+__cvsid__   = "$Id: tarfile.py 88586 2011-02-25 15:42:01Z marc-andre.lemburg $"
+__credits__ = "Gustavo Niemeyer, Niels Gust\u00e4bel, Richard Townsend."
+
+#---------
+# Imports
+#---------
+import sys
+import os
+import stat
+import errno
+import time
+import struct
+import copy
+import re
+
+try:
+    import grp, pwd
+except ImportError:
+    grp = pwd = None
+
+# os.symlink on Windows prior to 6.0 raises NotImplementedError
+symlink_exception = (AttributeError, NotImplementedError)
+try:
+    # WindowsError (1314) will be raised if the caller does not hold the
+    # SeCreateSymbolicLinkPrivilege privilege
+    symlink_exception += (WindowsError,)
+except NameError:
+    pass
+
+# from tarfile import *
+__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError"]
+
+if sys.version_info[0] < 3:
+    import __builtin__ as builtins
+else:
+    import builtins
+
+_open = builtins.open   # Since 'open' is TarFile.open
+
+#---------------------------------------------------------
+# tar constants
+#---------------------------------------------------------
+NUL = b"\0"                     # the null character
+BLOCKSIZE = 512                 # length of processing blocks
+RECORDSIZE = BLOCKSIZE * 20     # length of records
+GNU_MAGIC = b"ustar  \0"        # magic gnu tar string
+POSIX_MAGIC = b"ustar\x0000"    # magic posix tar string
+
+LENGTH_NAME = 100               # maximum length of a filename
+LENGTH_LINK = 100               # maximum length of a linkname
+LENGTH_PREFIX = 155             # maximum length of the prefix field
+
+REGTYPE = b"0"                  # regular file
+AREGTYPE = b"\0"                # regular file
+LNKTYPE = b"1"                  # link (inside tarfile)
+SYMTYPE = b"2"                  # symbolic link
+CHRTYPE = b"3"                  # character special device
+BLKTYPE = b"4"                  # block special device
+DIRTYPE = b"5"                  # directory
+FIFOTYPE = b"6"                 # fifo special device
+CONTTYPE = b"7"                 # contiguous file
+
+GNUTYPE_LONGNAME = b"L"         # GNU tar longname
+GNUTYPE_LONGLINK = b"K"         # GNU tar longlink
+GNUTYPE_SPARSE = b"S"           # GNU tar sparse file
+
+XHDTYPE = b"x"                  # POSIX.1-2001 extended header
+XGLTYPE = b"g"                  # POSIX.1-2001 global header
+SOLARIS_XHDTYPE = b"X"          # Solaris extended header
+
+USTAR_FORMAT = 0                # POSIX.1-1988 (ustar) format
+GNU_FORMAT = 1                  # GNU tar format
+PAX_FORMAT = 2                  # POSIX.1-2001 (pax) format
+DEFAULT_FORMAT = GNU_FORMAT
+
+#---------------------------------------------------------
+# tarfile constants
+#---------------------------------------------------------
+# File types that tarfile supports:
+SUPPORTED_TYPES = (REGTYPE, AREGTYPE, LNKTYPE,
+                   SYMTYPE, DIRTYPE, FIFOTYPE,
+                   CONTTYPE, CHRTYPE, BLKTYPE,
+                   GNUTYPE_LONGNAME, GNUTYPE_LONGLINK,
+                   GNUTYPE_SPARSE)
+
+# File types that will be treated as a regular file.
+REGULAR_TYPES = (REGTYPE, AREGTYPE,
+                 CONTTYPE, GNUTYPE_SPARSE)
+
+# File types that are part of the GNU tar format.
+GNU_TYPES = (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK,
+             GNUTYPE_SPARSE)
+
+# Fields from a pax header that override a TarInfo attribute.
+PAX_FIELDS = ("path", "linkpath", "size", "mtime",
+              "uid", "gid", "uname", "gname")
+
+# Fields from a pax header that are affected by hdrcharset.
+PAX_NAME_FIELDS = set(("path", "linkpath", "uname", "gname"))
+
+# Fields in a pax header that are numbers, all other fields
+# are treated as strings.
+PAX_NUMBER_FIELDS = {
+    "atime": float,
+    "ctime": float,
+    "mtime": float,
+    "uid": int,
+    "gid": int,
+    "size": int
+}
+
+#---------------------------------------------------------
+# Bits used in the mode field, values in octal.
+#---------------------------------------------------------
+S_IFLNK = 0o120000        # symbolic link
+S_IFREG = 0o100000        # regular file
+S_IFBLK = 0o060000        # block device
+S_IFDIR = 0o040000        # directory
+S_IFCHR = 0o020000        # character device
+S_IFIFO = 0o010000        # fifo
+
+TSUID   = 0o4000          # set UID on execution
+TSGID   = 0o2000          # set GID on execution
+TSVTX   = 0o1000          # reserved
+
+TUREAD  = 0o400           # read by owner
+TUWRITE = 0o200           # write by owner
+TUEXEC  = 0o100           # execute/search by owner
+TGREAD  = 0o040           # read by group
+TGWRITE = 0o020           # write by group
+TGEXEC  = 0o010           # execute/search by group
+TOREAD  = 0o004           # read by other
+TOWRITE = 0o002           # write by other
+TOEXEC  = 0o001           # execute/search by other
+
+#---------------------------------------------------------
+# initialization
+#---------------------------------------------------------
+if os.name in ("nt", "ce"):
+    ENCODING = "utf-8"
+else:
+    ENCODING = sys.getfilesystemencoding()
+
+#---------------------------------------------------------
+# Some useful functions
+#---------------------------------------------------------
+
+def stn(s, length, encoding, errors):
+    """Convert a string to a null-terminated bytes object.
+    """
+    s = s.encode(encoding, errors)
+    return s[:length] + (length - len(s)) * NUL
+
+def nts(s, encoding, errors):
+    """Convert a null-terminated bytes object to a string.
+    """
+    p = s.find(b"\0")
+    if p != -1:
+        s = s[:p]
+    return s.decode(encoding, errors)
+
+def nti(s):
+    """Convert a number field to a python number.
+    """
+    # There are two possible encodings for a number field, see
+    # itn() below.
+    if s[0] != chr(0o200):
+        try:
+            n = int(nts(s, "ascii", "strict") or "0", 8)
+        except ValueError:
+            raise InvalidHeaderError("invalid header")
+    else:
+        n = 0
+        for i in range(len(s) - 1):
+            n <<= 8
+            n += ord(s[i + 1])
+    return n
+
+def itn(n, digits=8, format=DEFAULT_FORMAT):
+    """Convert a python number to a number field.
+    """
+    # POSIX 1003.1-1988 requires numbers to be encoded as a string of
+    # octal digits followed by a null-byte, this allows values up to
+    # (8**(digits-1))-1. GNU tar allows storing numbers greater than
+    # that if necessary. A leading 0o200 byte indicates this particular
+    # encoding, the following digits-1 bytes are a big-endian
+    # representation. This allows values up to (256**(digits-1))-1.
+    if 0 <= n < 8 ** (digits - 1):
+        s = ("%0*o" % (digits - 1, n)).encode("ascii") + NUL
+    else:
+        if format != GNU_FORMAT or n >= 256 ** (digits - 1):
+            raise ValueError("overflow in number field")
+
+        if n < 0:
+            # XXX We mimic GNU tar's behaviour with negative numbers,
+            # this could raise OverflowError.
+            n = struct.unpack("L", struct.pack("l", n))[0]
+
+        s = bytearray()
+        for i in range(digits - 1):
+            s.insert(0, n & 0o377)
+            n >>= 8
+        s.insert(0, 0o200)
+    return s
+
+def calc_chksums(buf):
+    """Calculate the checksum for a member's header by summing up all
+       characters except for the chksum field which is treated as if
+       it was filled with spaces. According to the GNU tar sources,
+       some tars (Sun and NeXT) calculate chksum with signed char,
+       which will be different if there are chars in the buffer with
+       the high bit set. So we calculate two checksums, unsigned and
+       signed.
+    """
+    unsigned_chksum = 256 + sum(struct.unpack("148B", buf[:148]) + struct.unpack("356B", buf[156:512]))
+    signed_chksum = 256 + sum(struct.unpack("148b", buf[:148]) + struct.unpack("356b", buf[156:512]))
+    return unsigned_chksum, signed_chksum
+
+def copyfileobj(src, dst, length=None):
+    """Copy length bytes from fileobj src to fileobj dst.
+       If length is None, copy the entire content.
+    """
+    if length == 0:
+        return
+    if length is None:
+        while True:
+            buf = src.read(16*1024)
+            if not buf:
+                break
+            dst.write(buf)
+        return
+
+    BUFSIZE = 16 * 1024
+    blocks, remainder = divmod(length, BUFSIZE)
+    for b in range(blocks):
+        buf = src.read(BUFSIZE)
+        if len(buf) < BUFSIZE:
+            raise IOError("end of file reached")
+        dst.write(buf)
+
+    if remainder != 0:
+        buf = src.read(remainder)
+        if len(buf) < remainder:
+            raise IOError("end of file reached")
+        dst.write(buf)
+    return
+
+filemode_table = (
+    ((S_IFLNK,      "l"),
+     (S_IFREG,      "-"),
+     (S_IFBLK,      "b"),
+     (S_IFDIR,      "d"),
+     (S_IFCHR,      "c"),
+     (S_IFIFO,      "p")),
+
+    ((TUREAD,       "r"),),
+    ((TUWRITE,      "w"),),
+    ((TUEXEC|TSUID, "s"),
+     (TSUID,        "S"),
+     (TUEXEC,       "x")),
+
+    ((TGREAD,       "r"),),
+    ((TGWRITE,      "w"),),
+    ((TGEXEC|TSGID, "s"),
+     (TSGID,        "S"),
+     (TGEXEC,       "x")),
+
+    ((TOREAD,       "r"),),
+    ((TOWRITE,      "w"),),
+    ((TOEXEC|TSVTX, "t"),
+     (TSVTX,        "T"),
+     (TOEXEC,       "x"))
+)
+
+def filemode(mode):
+    """Convert a file's mode to a string of the form
+       -rwxrwxrwx.
+       Used by TarFile.list()
+    """
+    perm = []
+    for table in filemode_table:
+        for bit, char in table:
+            if mode & bit == bit:
+                perm.append(char)
+                break
+        else:
+            perm.append("-")
+    return "".join(perm)
+
+class TarError(Exception):
+    """Base exception."""
+    pass
+class ExtractError(TarError):
+    """General exception for extract errors."""
+    pass
+class ReadError(TarError):
+    """Exception for unreadable tar archives."""
+    pass
+class CompressionError(TarError):
+    """Exception for unavailable compression methods."""
+    pass
+class StreamError(TarError):
+    """Exception for unsupported operations on stream-like TarFiles."""
+    pass
+class HeaderError(TarError):
+    """Base exception for header errors."""
+    pass
+class EmptyHeaderError(HeaderError):
+    """Exception for empty headers."""
+    pass
+class TruncatedHeaderError(HeaderError):
+    """Exception for truncated headers."""
+    pass
+class EOFHeaderError(HeaderError):
+    """Exception for end of file headers."""
+    pass
+class InvalidHeaderError(HeaderError):
+    """Exception for invalid headers."""
+    pass
+class SubsequentHeaderError(HeaderError):
+    """Exception for missing and invalid extended headers."""
+    pass
+
+#---------------------------
+# internal stream interface
+#---------------------------
+class _LowLevelFile(object):
+    """Low-level file object. Supports reading and writing.
+       It is used instead of a regular file object for streaming
+       access.
+    """
+
+    def __init__(self, name, mode):
+        mode = {
+            "r": os.O_RDONLY,
+            "w": os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+        }[mode]
+        if hasattr(os, "O_BINARY"):
+            mode |= os.O_BINARY
+        self.fd = os.open(name, mode, 0o666)
+
+    def close(self):
+        os.close(self.fd)
+
+    def read(self, size):
+        return os.read(self.fd, size)
+
+    def write(self, s):
+        os.write(self.fd, s)
+
+class _Stream(object):
+    """Class that serves as an adapter between TarFile and
+       a stream-like object.  The stream-like object only
+       needs to have a read() or write() method and is accessed
+       blockwise.  Use of gzip or bzip2 compression is possible.
+       A stream-like object could be for example: sys.stdin,
+       sys.stdout, a socket, a tape device etc.
+
+       _Stream is intended to be used only internally.
+    """
+
+    def __init__(self, name, mode, comptype, fileobj, bufsize):
+        """Construct a _Stream object.
+        """
+        self._extfileobj = True
+        if fileobj is None:
+            fileobj = _LowLevelFile(name, mode)
+            self._extfileobj = False
+
+        if comptype == '*':
+            # Enable transparent compression detection for the
+            # stream interface
+            fileobj = _StreamProxy(fileobj)
+            comptype = fileobj.getcomptype()
+
+        self.name     = name or ""
+        self.mode     = mode
+        self.comptype = comptype
+        self.fileobj  = fileobj
+        self.bufsize  = bufsize
+        self.buf      = b""
+        self.pos      = 0
+        self.closed   = False
+
+        try:
+            if comptype == "gz":
+                try:
+                    import zlib
+                except ImportError:
+                    raise CompressionError("zlib module is not available")
+                self.zlib = zlib
+                self.crc = zlib.crc32(b"")
+                if mode == "r":
+                    self._init_read_gz()
+                else:
+                    self._init_write_gz()
+
+            if comptype == "bz2":
+                try:
+                    import bz2
+                except ImportError:
+                    raise CompressionError("bz2 module is not available")
+                if mode == "r":
+                    self.dbuf = b""
+                    self.cmp = bz2.BZ2Decompressor()
+                else:
+                    self.cmp = bz2.BZ2Compressor()
+        except:
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+            raise
+
+    def __del__(self):
+        if hasattr(self, "closed") and not self.closed:
+            self.close()
+
+    def _init_write_gz(self):
+        """Initialize for writing with gzip compression.
+        """
+        self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED,
+                                            -self.zlib.MAX_WBITS,
+                                            self.zlib.DEF_MEM_LEVEL,
+                                            0)
+        timestamp = struct.pack("<L", int(time.time()))
+        self.__write(b"\037\213\010\010" + timestamp + b"\002\377")
+        if self.name.endswith(".gz"):
+            self.name = self.name[:-3]
+        # RFC1952 says we must use ISO-8859-1 for the FNAME field.
+        self.__write(self.name.encode("iso-8859-1", "replace") + NUL)
+
+    def write(self, s):
+        """Write string s to the stream.
+        """
+        if self.comptype == "gz":
+            self.crc = self.zlib.crc32(s, self.crc)
+        self.pos += len(s)
+        if self.comptype != "tar":
+            s = self.cmp.compress(s)
+        self.__write(s)
+
+    def __write(self, s):
+        """Write string s to the stream if a whole new block
+           is ready to be written.
+        """
+        self.buf += s
+        while len(self.buf) > self.bufsize:
+            self.fileobj.write(self.buf[:self.bufsize])
+            self.buf = self.buf[self.bufsize:]
+
+    def close(self):
+        """Close the _Stream object. No operation should be
+           done on it afterwards.
+        """
+        if self.closed:
+            return
+
+        if self.mode == "w" and self.comptype != "tar":
+            self.buf += self.cmp.flush()
+
+        if self.mode == "w" and self.buf:
+            self.fileobj.write(self.buf)
+            self.buf = b""
+            if self.comptype == "gz":
+                # The native zlib crc is an unsigned 32-bit integer, but
+                # the Python wrapper implicitly casts that to a signed C
+                # long.  So, on a 32-bit box self.crc may "look negative",
+                # while the same crc on a 64-bit box may "look positive".
+                # To avoid irksome warnings from the `struct` module, force
+                # it to look positive on all boxes.
+                self.fileobj.write(struct.pack("<L", self.crc & 0xffffffff))
+                self.fileobj.write(struct.pack("<L", self.pos & 0xffffFFFF))
+
+        if not self._extfileobj:
+            self.fileobj.close()
+
+        self.closed = True
+
+    def _init_read_gz(self):
+        """Initialize for reading a gzip compressed fileobj.
+        """
+        self.cmp = self.zlib.decompressobj(-self.zlib.MAX_WBITS)
+        self.dbuf = b""
+
+        # taken from gzip.GzipFile with some alterations
+        if self.__read(2) != b"\037\213":
+            raise ReadError("not a gzip file")
+        if self.__read(1) != b"\010":
+            raise CompressionError("unsupported compression method")
+
+        flag = ord(self.__read(1))
+        self.__read(6)
+
+        if flag & 4:
+            xlen = ord(self.__read(1)) + 256 * ord(self.__read(1))
+            self.read(xlen)
+        if flag & 8:
+            while True:
+                s = self.__read(1)
+                if not s or s == NUL:
+                    break
+        if flag & 16:
+            while True:
+                s = self.__read(1)
+                if not s or s == NUL:
+                    break
+        if flag & 2:
+            self.__read(2)
+
+    def tell(self):
+        """Return the stream's file pointer position.
+        """
+        return self.pos
+
+    def seek(self, pos=0):
+        """Set the stream's file pointer to pos. Negative seeking
+           is forbidden.
+        """
+        if pos - self.pos >= 0:
+            blocks, remainder = divmod(pos - self.pos, self.bufsize)
+            for i in range(blocks):
+                self.read(self.bufsize)
+            self.read(remainder)
+        else:
+            raise StreamError("seeking backwards is not allowed")
+        return self.pos
+
+    def read(self, size=None):
+        """Return the next size number of bytes from the stream.
+           If size is not defined, return all bytes of the stream
+           up to EOF.
+        """
+        if size is None:
+            t = []
+            while True:
+                buf = self._read(self.bufsize)
+                if not buf:
+                    break
+                t.append(buf)
+            buf = "".join(t)
+        else:
+            buf = self._read(size)
+        self.pos += len(buf)
+        return buf
+
+    def _read(self, size):
+        """Return size bytes from the stream.
+        """
+        if self.comptype == "tar":
+            return self.__read(size)
+
+        c = len(self.dbuf)
+        while c < size:
+            buf = self.__read(self.bufsize)
+            if not buf:
+                break
+            try:
+                buf = self.cmp.decompress(buf)
+            except IOError:
+                raise ReadError("invalid compressed data")
+            self.dbuf += buf
+            c += len(buf)
+        buf = self.dbuf[:size]
+        self.dbuf = self.dbuf[size:]
+        return buf
+
+    def __read(self, size):
+        """Return size bytes from stream. If internal buffer is empty,
+           read another block from the stream.
+        """
+        c = len(self.buf)
+        while c < size:
+            buf = self.fileobj.read(self.bufsize)
+            if not buf:
+                break
+            self.buf += buf
+            c += len(buf)
+        buf = self.buf[:size]
+        self.buf = self.buf[size:]
+        return buf
+# class _Stream
+
+class _StreamProxy(object):
+    """Small proxy class that enables transparent compression
+       detection for the Stream interface (mode 'r|*').
+    """
+
+    def __init__(self, fileobj):
+        self.fileobj = fileobj
+        self.buf = self.fileobj.read(BLOCKSIZE)
+
+    def read(self, size):
+        self.read = self.fileobj.read
+        return self.buf
+
+    def getcomptype(self):
+        if self.buf.startswith(b"\037\213\010"):
+            return "gz"
+        if self.buf.startswith(b"BZh91"):
+            return "bz2"
+        return "tar"
+
+    def close(self):
+        self.fileobj.close()
+# class StreamProxy
+
+class _BZ2Proxy(object):
+    """Small proxy class that enables external file object
+       support for "r:bz2" and "w:bz2" modes. This is actually
+       a workaround for a limitation in bz2 module's BZ2File
+       class which (unlike gzip.GzipFile) has no support for
+       a file object argument.
+    """
+
+    blocksize = 16 * 1024
+
+    def __init__(self, fileobj, mode):
+        self.fileobj = fileobj
+        self.mode = mode
+        self.name = getattr(self.fileobj, "name", None)
+        self.init()
+
+    def init(self):
+        import bz2
+        self.pos = 0
+        if self.mode == "r":
+            self.bz2obj = bz2.BZ2Decompressor()
+            self.fileobj.seek(0)
+            self.buf = b""
+        else:
+            self.bz2obj = bz2.BZ2Compressor()
+
+    def read(self, size):
+        x = len(self.buf)
+        while x < size:
+            raw = self.fileobj.read(self.blocksize)
+            if not raw:
+                break
+            data = self.bz2obj.decompress(raw)
+            self.buf += data
+            x += len(data)
+
+        buf = self.buf[:size]
+        self.buf = self.buf[size:]
+        self.pos += len(buf)
+        return buf
+
+    def seek(self, pos):
+        if pos < self.pos:
+            self.init()
+        self.read(pos - self.pos)
+
+    def tell(self):
+        return self.pos
+
+    def write(self, data):
+        self.pos += len(data)
+        raw = self.bz2obj.compress(data)
+        self.fileobj.write(raw)
+
+    def close(self):
+        if self.mode == "w":
+            raw = self.bz2obj.flush()
+            self.fileobj.write(raw)
+# class _BZ2Proxy
+
+#------------------------
+# Extraction file object
+#------------------------
+class _FileInFile(object):
+    """A thin wrapper around an existing file object that
+       provides a part of its data as an individual file
+       object.
+    """
+
+    def __init__(self, fileobj, offset, size, blockinfo=None):
+        self.fileobj = fileobj
+        self.offset = offset
+        self.size = size
+        self.position = 0
+
+        if blockinfo is None:
+            blockinfo = [(0, size)]
+
+        # Construct a map with data and zero blocks.
+        self.map_index = 0
+        self.map = []
+        lastpos = 0
+        realpos = self.offset
+        for offset, size in blockinfo:
+            if offset > lastpos:
+                self.map.append((False, lastpos, offset, None))
+            self.map.append((True, offset, offset + size, realpos))
+            realpos += size
+            lastpos = offset + size
+        if lastpos < self.size:
+            self.map.append((False, lastpos, self.size, None))
+
+    def seekable(self):
+        if not hasattr(self.fileobj, "seekable"):
+            # XXX gzip.GzipFile and bz2.BZ2File
+            return True
+        return self.fileobj.seekable()
+
+    def tell(self):
+        """Return the current file position.
+        """
+        return self.position
+
+    def seek(self, position):
+        """Seek to a position in the file.
+        """
+        self.position = position
+
+    def read(self, size=None):
+        """Read data from the file.
+        """
+        if size is None:
+            size = self.size - self.position
+        else:
+            size = min(size, self.size - self.position)
+
+        buf = b""
+        while size > 0:
+            while True:
+                data, start, stop, offset = self.map[self.map_index]
+                if start <= self.position < stop:
+                    break
+                else:
+                    self.map_index += 1
+                    if self.map_index == len(self.map):
+                        self.map_index = 0
+            length = min(size, stop - self.position)
+            if data:
+                self.fileobj.seek(offset + (self.position - start))
+                buf += self.fileobj.read(length)
+            else:
+                buf += NUL * length
+            size -= length
+            self.position += length
+        return buf
+#class _FileInFile
+
+
+class ExFileObject(object):
+    """File-like object for reading an archive member.
+       Is returned by TarFile.extractfile().
+    """
+    blocksize = 1024
+
+    def __init__(self, tarfile, tarinfo):
+        self.fileobj = _FileInFile(tarfile.fileobj,
+                                   tarinfo.offset_data,
+                                   tarinfo.size,
+                                   tarinfo.sparse)
+        self.name = tarinfo.name
+        self.mode = "r"
+        self.closed = False
+        self.size = tarinfo.size
+
+        self.position = 0
+        self.buffer = b""
+
+    def readable(self):
+        return True
+
+    def writable(self):
+        return False
+
+    def seekable(self):
+        return self.fileobj.seekable()
+
+    def read(self, size=None):
+        """Read at most size bytes from the file. If size is not
+           present or None, read all data until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        buf = b""
+        if self.buffer:
+            if size is None:
+                buf = self.buffer
+                self.buffer = b""
+            else:
+                buf = self.buffer[:size]
+                self.buffer = self.buffer[size:]
+
+        if size is None:
+            buf += self.fileobj.read()
+        else:
+            buf += self.fileobj.read(size - len(buf))
+
+        self.position += len(buf)
+        return buf
+
+    # XXX TextIOWrapper uses the read1() method.
+    read1 = read
+
+    def readline(self, size=-1):
+        """Read one entire line from the file. If size is present
+           and non-negative, return a string with at most that
+           size, which may be an incomplete line.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        pos = self.buffer.find(b"\n") + 1
+        if pos == 0:
+            # no newline found.
+            while True:
+                buf = self.fileobj.read(self.blocksize)
+                self.buffer += buf
+                if not buf or b"\n" in buf:
+                    pos = self.buffer.find(b"\n") + 1
+                    if pos == 0:
+                        # no newline found.
+                        pos = len(self.buffer)
+                    break
+
+        if size != -1:
+            pos = min(size, pos)
+
+        buf = self.buffer[:pos]
+        self.buffer = self.buffer[pos:]
+        self.position += len(buf)
+        return buf
+
+    def readlines(self):
+        """Return a list with all remaining lines.
+        """
+        result = []
+        while True:
+            line = self.readline()
+            if not line: break
+            result.append(line)
+        return result
+
+    def tell(self):
+        """Return the current file position.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        return self.position
+
+    def seek(self, pos, whence=os.SEEK_SET):
+        """Seek to a position in the file.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+
+        if whence == os.SEEK_SET:
+            self.position = min(max(pos, 0), self.size)
+        elif whence == os.SEEK_CUR:
+            if pos < 0:
+                self.position = max(self.position + pos, 0)
+            else:
+                self.position = min(self.position + pos, self.size)
+        elif whence == os.SEEK_END:
+            self.position = max(min(self.size + pos, self.size), 0)
+        else:
+            raise ValueError("Invalid argument")
+
+        self.buffer = b""
+        self.fileobj.seek(self.position)
+
+    def close(self):
+        """Close the file object.
+        """
+        self.closed = True
+
+    def __iter__(self):
+        """Get an iterator over the file's lines.
+        """
+        while True:
+            line = self.readline()
+            if not line:
+                break
+            yield line
+#class ExFileObject
+
+#------------------
+# Exported Classes
+#------------------
+class TarInfo(object):
+    """Informational class which holds the details about an
+       archive member given by a tar header block.
+       TarInfo objects are returned by TarFile.getmember(),
+       TarFile.getmembers() and TarFile.gettarinfo() and are
+       usually created internally.
+    """
+
+    __slots__ = ("name", "mode", "uid", "gid", "size", "mtime",
+                 "chksum", "type", "linkname", "uname", "gname",
+                 "devmajor", "devminor",
+                 "offset", "offset_data", "pax_headers", "sparse",
+                 "tarfile", "_sparse_structs", "_link_target")
+
+    def __init__(self, name=""):
+        """Construct a TarInfo object. name is the optional name
+           of the member.
+        """
+        self.name = name        # member name
+        self.mode = 0o644       # file permissions
+        self.uid = 0            # user id
+        self.gid = 0            # group id
+        self.size = 0           # file size
+        self.mtime = 0          # modification time
+        self.chksum = 0         # header checksum
+        self.type = REGTYPE     # member type
+        self.linkname = ""      # link name
+        self.uname = ""         # user name
+        self.gname = ""         # group name
+        self.devmajor = 0       # device major number
+        self.devminor = 0       # device minor number
+
+        self.offset = 0         # the tar header starts here
+        self.offset_data = 0    # the file's data starts here
+
+        self.sparse = None      # sparse member information
+        self.pax_headers = {}   # pax header information
+
+    # In pax headers the "name" and "linkname" field are called
+    # "path" and "linkpath".
+    def _getpath(self):
+        return self.name
+    def _setpath(self, name):
+        self.name = name
+    path = property(_getpath, _setpath)
+
+    def _getlinkpath(self):
+        return self.linkname
+    def _setlinkpath(self, linkname):
+        self.linkname = linkname
+    linkpath = property(_getlinkpath, _setlinkpath)
+
+    def __repr__(self):
+        return "<%s %r at %#x>" % (self.__class__.__name__,self.name,id(self))
+
+    def get_info(self):
+        """Return the TarInfo's attributes as a dictionary.
+        """
+        info = {
+            "name":     self.name,
+            "mode":     self.mode & 0o7777,
+            "uid":      self.uid,
+            "gid":      self.gid,
+            "size":     self.size,
+            "mtime":    self.mtime,
+            "chksum":   self.chksum,
+            "type":     self.type,
+            "linkname": self.linkname,
+            "uname":    self.uname,
+            "gname":    self.gname,
+            "devmajor": self.devmajor,
+            "devminor": self.devminor
+        }
+
+        if info["type"] == DIRTYPE and not info["name"].endswith("/"):
+            info["name"] += "/"
+
+        return info
+
+    def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"):
+        """Return a tar header as a string of 512 byte blocks.
+        """
+        info = self.get_info()
+
+        if format == USTAR_FORMAT:
+            return self.create_ustar_header(info, encoding, errors)
+        elif format == GNU_FORMAT:
+            return self.create_gnu_header(info, encoding, errors)
+        elif format == PAX_FORMAT:
+            return self.create_pax_header(info, encoding)
+        else:
+            raise ValueError("invalid format")
+
+    def create_ustar_header(self, info, encoding, errors):
+        """Return the object as a ustar header block.
+        """
+        info["magic"] = POSIX_MAGIC
+
+        if len(info["linkname"]) > LENGTH_LINK:
+            raise ValueError("linkname is too long")
+
+        if len(info["name"]) > LENGTH_NAME:
+            info["prefix"], info["name"] = self._posix_split_name(info["name"])
+
+        return self._create_header(info, USTAR_FORMAT, encoding, errors)
+
+    def create_gnu_header(self, info, encoding, errors):
+        """Return the object as a GNU header block sequence.
+        """
+        info["magic"] = GNU_MAGIC
+
+        buf = b""
+        if len(info["linkname"]) > LENGTH_LINK:
+            buf += self._create_gnu_long_header(info["linkname"], GNUTYPE_LONGLINK, encoding, errors)
+
+        if len(info["name"]) > LENGTH_NAME:
+            buf += self._create_gnu_long_header(info["name"], GNUTYPE_LONGNAME, encoding, errors)
+
+        return buf + self._create_header(info, GNU_FORMAT, encoding, errors)
+
+    def create_pax_header(self, info, encoding):
+        """Return the object as a ustar header block. If it cannot be
+           represented this way, prepend a pax extended header sequence
+           with supplement information.
+        """
+        info["magic"] = POSIX_MAGIC
+        pax_headers = self.pax_headers.copy()
+
+        # Test string fields for values that exceed the field length or cannot
+        # be represented in ASCII encoding.
+        for name, hname, length in (
+                ("name", "path", LENGTH_NAME), ("linkname", "linkpath", LENGTH_LINK),
+                ("uname", "uname", 32), ("gname", "gname", 32)):
+
+            if hname in pax_headers:
+                # The pax header has priority.
+                continue
+
+            # Try to encode the string as ASCII.
+            try:
+                info[name].encode("ascii", "strict")
+            except UnicodeEncodeError:
+                pax_headers[hname] = info[name]
+                continue
+
+            if len(info[name]) > length:
+                pax_headers[hname] = info[name]
+
+        # Test number fields for values that exceed the field limit or values
+        # that like to be stored as float.
+        for name, digits in (("uid", 8), ("gid", 8), ("size", 12), ("mtime", 12)):
+            if name in pax_headers:
+                # The pax header has priority. Avoid overflow.
+                info[name] = 0
+                continue
+
+            val = info[name]
+            if not 0 <= val < 8 ** (digits - 1) or isinstance(val, float):
+                pax_headers[name] = str(val)
+                info[name] = 0
+
+        # Create a pax extended header if necessary.
+        if pax_headers:
+            buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding)
+        else:
+            buf = b""
+
+        return buf + self._create_header(info, USTAR_FORMAT, "ascii", "replace")
+
+    @classmethod
+    def create_pax_global_header(cls, pax_headers):
+        """Return the object as a pax global header block sequence.
+        """
+        return cls._create_pax_generic_header(pax_headers, XGLTYPE, "utf8")
+
+    def _posix_split_name(self, name):
+        """Split a name longer than 100 chars into a prefix
+           and a name part.
+        """
+        prefix = name[:LENGTH_PREFIX + 1]
+        while prefix and prefix[-1] != "/":
+            prefix = prefix[:-1]
+
+        name = name[len(prefix):]
+        prefix = prefix[:-1]
+
+        if not prefix or len(name) > LENGTH_NAME:
+            raise ValueError("name is too long")
+        return prefix, name
+
+    @staticmethod
+    def _create_header(info, format, encoding, errors):
+        """Return a header block. info is a dictionary with file
+           information, format must be one of the *_FORMAT constants.
+        """
+        parts = [
+            stn(info.get("name", ""), 100, encoding, errors),
+            itn(info.get("mode", 0) & 0o7777, 8, format),
+            itn(info.get("uid", 0), 8, format),
+            itn(info.get("gid", 0), 8, format),
+            itn(info.get("size", 0), 12, format),
+            itn(info.get("mtime", 0), 12, format),
+            b"        ", # checksum field
+            info.get("type", REGTYPE),
+            stn(info.get("linkname", ""), 100, encoding, errors),
+            info.get("magic", POSIX_MAGIC),
+            stn(info.get("uname", ""), 32, encoding, errors),
+            stn(info.get("gname", ""), 32, encoding, errors),
+            itn(info.get("devmajor", 0), 8, format),
+            itn(info.get("devminor", 0), 8, format),
+            stn(info.get("prefix", ""), 155, encoding, errors)
+        ]
+
+        buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts))
+        chksum = calc_chksums(buf[-BLOCKSIZE:])[0]
+        buf = buf[:-364] + ("%06o\0" % chksum).encode("ascii") + buf[-357:]
+        return buf
+
+    @staticmethod
+    def _create_payload(payload):
+        """Return the string payload filled with zero bytes
+           up to the next 512 byte border.
+        """
+        blocks, remainder = divmod(len(payload), BLOCKSIZE)
+        if remainder > 0:
+            payload += (BLOCKSIZE - remainder) * NUL
+        return payload
+
+    @classmethod
+    def _create_gnu_long_header(cls, name, type, encoding, errors):
+        """Return a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence
+           for name.
+        """
+        name = name.encode(encoding, errors) + NUL
+
+        info = {}
+        info["name"] = "././@LongLink"
+        info["type"] = type
+        info["size"] = len(name)
+        info["magic"] = GNU_MAGIC
+
+        # create extended header + name blocks.
+        return cls._create_header(info, USTAR_FORMAT, encoding, errors) + \
+                cls._create_payload(name)
+
+    @classmethod
+    def _create_pax_generic_header(cls, pax_headers, type, encoding):
+        """Return a POSIX.1-2008 extended or global header sequence
+           that contains a list of keyword, value pairs. The values
+           must be strings.
+        """
+        # Check if one of the fields contains surrogate characters and thereby
+        # forces hdrcharset=BINARY, see _proc_pax() for more information.
+        binary = False
+        for keyword, value in pax_headers.items():
+            try:
+                value.encode("utf8", "strict")
+            except UnicodeEncodeError:
+                binary = True
+                break
+
+        records = b""
+        if binary:
+            # Put the hdrcharset field at the beginning of the header.
+            records += b"21 hdrcharset=BINARY\n"
+
+        for keyword, value in pax_headers.items():
+            keyword = keyword.encode("utf8")
+            if binary:
+                # Try to restore the original byte representation of `value'.
+                # Needless to say, that the encoding must match the string.
+                value = value.encode(encoding, "surrogateescape")
+            else:
+                value = value.encode("utf8")
+
+            l = len(keyword) + len(value) + 3   # ' ' + '=' + '\n'
+            n = p = 0
+            while True:
+                n = l + len(str(p))
+                if n == p:
+                    break
+                p = n
+            records += bytes(str(p), "ascii") + b" " + keyword + b"=" + value + b"\n"
+
+        # We use a hardcoded "././@PaxHeader" name like star does
+        # instead of the one that POSIX recommends.
+        info = {}
+        info["name"] = "././@PaxHeader"
+        info["type"] = type
+        info["size"] = len(records)
+        info["magic"] = POSIX_MAGIC
+
+        # Create pax header + record blocks.
+        return cls._create_header(info, USTAR_FORMAT, "ascii", "replace") + \
+                cls._create_payload(records)
+
+    @classmethod
+    def frombuf(cls, buf, encoding, errors):
+        """Construct a TarInfo object from a 512 byte bytes object.
+        """
+        if len(buf) == 0:
+            raise EmptyHeaderError("empty header")
+        if len(buf) != BLOCKSIZE:
+            raise TruncatedHeaderError("truncated header")
+        if buf.count(NUL) == BLOCKSIZE:
+            raise EOFHeaderError("end of file header")
+
+        chksum = nti(buf[148:156])
+        if chksum not in calc_chksums(buf):
+            raise InvalidHeaderError("bad checksum")
+
+        obj = cls()
+        obj.name = nts(buf[0:100], encoding, errors)
+        obj.mode = nti(buf[100:108])
+        obj.uid = nti(buf[108:116])
+        obj.gid = nti(buf[116:124])
+        obj.size = nti(buf[124:136])
+        obj.mtime = nti(buf[136:148])
+        obj.chksum = chksum
+        obj.type = buf[156:157]
+        obj.linkname = nts(buf[157:257], encoding, errors)
+        obj.uname = nts(buf[265:297], encoding, errors)
+        obj.gname = nts(buf[297:329], encoding, errors)
+        obj.devmajor = nti(buf[329:337])
+        obj.devminor = nti(buf[337:345])
+        prefix = nts(buf[345:500], encoding, errors)
+
+        # Old V7 tar format represents a directory as a regular
+        # file with a trailing slash.
+        if obj.type == AREGTYPE and obj.name.endswith("/"):
+            obj.type = DIRTYPE
+
+        # The old GNU sparse format occupies some of the unused
+        # space in the buffer for up to 4 sparse structures.
+        # Save the them for later processing in _proc_sparse().
+        if obj.type == GNUTYPE_SPARSE:
+            pos = 386
+            structs = []
+            for i in range(4):
+                try:
+                    offset = nti(buf[pos:pos + 12])
+                    numbytes = nti(buf[pos + 12:pos + 24])
+                except ValueError:
+                    break
+                structs.append((offset, numbytes))
+                pos += 24
+            isextended = bool(buf[482])
+            origsize = nti(buf[483:495])
+            obj._sparse_structs = (structs, isextended, origsize)
+
+        # Remove redundant slashes from directories.
+        if obj.isdir():
+            obj.name = obj.name.rstrip("/")
+
+        # Reconstruct a ustar longname.
+        if prefix and obj.type not in GNU_TYPES:
+            obj.name = prefix + "/" + obj.name
+        return obj
+
+    @classmethod
+    def fromtarfile(cls, tarfile):
+        """Return the next TarInfo object from TarFile object
+           tarfile.
+        """
+        buf = tarfile.fileobj.read(BLOCKSIZE)
+        obj = cls.frombuf(buf, tarfile.encoding, tarfile.errors)
+        obj.offset = tarfile.fileobj.tell() - BLOCKSIZE
+        return obj._proc_member(tarfile)
+
+    #--------------------------------------------------------------------------
+    # The following are methods that are called depending on the type of a
+    # member. The entry point is _proc_member() which can be overridden in a
+    # subclass to add custom _proc_*() methods. A _proc_*() method MUST
+    # implement the following
+    # operations:
+    # 1. Set self.offset_data to the position where the data blocks begin,
+    #    if there is data that follows.
+    # 2. Set tarfile.offset to the position where the next member's header will
+    #    begin.
+    # 3. Return self or another valid TarInfo object.
+    def _proc_member(self, tarfile):
+        """Choose the right processing method depending on
+           the type and call it.
+        """
+        if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK):
+            return self._proc_gnulong(tarfile)
+        elif self.type == GNUTYPE_SPARSE:
+            return self._proc_sparse(tarfile)
+        elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE):
+            return self._proc_pax(tarfile)
+        else:
+            return self._proc_builtin(tarfile)
+
+    def _proc_builtin(self, tarfile):
+        """Process a builtin type or an unknown type which
+           will be treated as a regular file.
+        """
+        self.offset_data = tarfile.fileobj.tell()
+        offset = self.offset_data
+        if self.isreg() or self.type not in SUPPORTED_TYPES:
+            # Skip the following data blocks.
+            offset += self._block(self.size)
+        tarfile.offset = offset
+
+        # Patch the TarInfo object with saved global
+        # header information.
+        self._apply_pax_info(tarfile.pax_headers, tarfile.encoding, tarfile.errors)
+
+        return self
+
+    def _proc_gnulong(self, tarfile):
+        """Process the blocks that hold a GNU longname
+           or longlink member.
+        """
+        buf = tarfile.fileobj.read(self._block(self.size))
+
+        # Fetch the next header and process it.
+        try:
+            next = self.fromtarfile(tarfile)
+        except HeaderError:
+            raise SubsequentHeaderError("missing or bad subsequent header")
+
+        # Patch the TarInfo object from the next header with
+        # the longname information.
+        next.offset = self.offset
+        if self.type == GNUTYPE_LONGNAME:
+            next.name = nts(buf, tarfile.encoding, tarfile.errors)
+        elif self.type == GNUTYPE_LONGLINK:
+            next.linkname = nts(buf, tarfile.encoding, tarfile.errors)
+
+        return next
+
+    def _proc_sparse(self, tarfile):
+        """Process a GNU sparse header plus extra headers.
+        """
+        # We already collected some sparse structures in frombuf().
+        structs, isextended, origsize = self._sparse_structs
+        del self._sparse_structs
+
+        # Collect sparse structures from extended header blocks.
+        while isextended:
+            buf = tarfile.fileobj.read(BLOCKSIZE)
+            pos = 0
+            for i in range(21):
+                try:
+                    offset = nti(buf[pos:pos + 12])
+                    numbytes = nti(buf[pos + 12:pos + 24])
+                except ValueError:
+                    break
+                if offset and numbytes:
+                    structs.append((offset, numbytes))
+                pos += 24
+            isextended = bool(buf[504])
+        self.sparse = structs
+
+        self.offset_data = tarfile.fileobj.tell()
+        tarfile.offset = self.offset_data + self._block(self.size)
+        self.size = origsize
+        return self
+
+    def _proc_pax(self, tarfile):
+        """Process an extended or global header as described in
+           POSIX.1-2008.
+        """
+        # Read the header information.
+        buf = tarfile.fileobj.read(self._block(self.size))
+
+        # A pax header stores supplemental information for either
+        # the following file (extended) or all following files
+        # (global).
+        if self.type == XGLTYPE:
+            pax_headers = tarfile.pax_headers
+        else:
+            pax_headers = tarfile.pax_headers.copy()
+
+        # Check if the pax header contains a hdrcharset field. This tells us
+        # the encoding of the path, linkpath, uname and gname fields. Normally,
+        # these fields are UTF-8 encoded but since POSIX.1-2008 tar
+        # implementations are allowed to store them as raw binary strings if
+        # the translation to UTF-8 fails.
+        match = re.search(br"\d+ hdrcharset=([^\n]+)\n", buf)
+        if match is not None:
+            pax_headers["hdrcharset"] = match.group(1).decode("utf8")
+
+        # For the time being, we don't care about anything other than "BINARY".
+        # The only other value that is currently allowed by the standard is
+        # "ISO-IR 10646 2000 UTF-8" in other words UTF-8.
+        hdrcharset = pax_headers.get("hdrcharset")
+        if hdrcharset == "BINARY":
+            encoding = tarfile.encoding
+        else:
+            encoding = "utf8"
+
+        # Parse pax header information. A record looks like that:
+        # "%d %s=%s\n" % (length, keyword, value). length is the size
+        # of the complete record including the length field itself and
+        # the newline. keyword and value are both UTF-8 encoded strings.
+        regex = re.compile(br"(\d+) ([^=]+)=")
+        pos = 0
+        while True:
+            match = regex.match(buf, pos)
+            if not match:
+                break
+
+            length, keyword = match.groups()
+            length = int(length)
+            value = buf[match.end(2) + 1:match.start(1) + length - 1]
+
+            # Normally, we could just use "utf8" as the encoding and "strict"
+            # as the error handler, but we better not take the risk. For
+            # example, GNU tar <= 1.23 is known to store filenames it cannot
+            # translate to UTF-8 as raw strings (unfortunately without a
+            # hdrcharset=BINARY header).
+            # We first try the strict standard encoding, and if that fails we
+            # fall back on the user's encoding and error handler.
+            keyword = self._decode_pax_field(keyword, "utf8", "utf8",
+                    tarfile.errors)
+            if keyword in PAX_NAME_FIELDS:
+                value = self._decode_pax_field(value, encoding, tarfile.encoding,
+                        tarfile.errors)
+            else:
+                value = self._decode_pax_field(value, "utf8", "utf8",
+                        tarfile.errors)
+
+            pax_headers[keyword] = value
+            pos += length
+
+        # Fetch the next header.
+        try:
+            next = self.fromtarfile(tarfile)
+        except HeaderError:
+            raise SubsequentHeaderError("missing or bad subsequent header")
+
+        # Process GNU sparse information.
+        if "GNU.sparse.map" in pax_headers:
+            # GNU extended sparse format version 0.1.
+            self._proc_gnusparse_01(next, pax_headers)
+
+        elif "GNU.sparse.size" in pax_headers:
+            # GNU extended sparse format version 0.0.
+            self._proc_gnusparse_00(next, pax_headers, buf)
+
+        elif pax_headers.get("GNU.sparse.major") == "1" and pax_headers.get("GNU.sparse.minor") == "0":
+            # GNU extended sparse format version 1.0.
+            self._proc_gnusparse_10(next, pax_headers, tarfile)
+
+        if self.type in (XHDTYPE, SOLARIS_XHDTYPE):
+            # Patch the TarInfo object with the extended header info.
+            next._apply_pax_info(pax_headers, tarfile.encoding, tarfile.errors)
+            next.offset = self.offset
+
+            if "size" in pax_headers:
+                # If the extended header replaces the size field,
+                # we need to recalculate the offset where the next
+                # header starts.
+                offset = next.offset_data
+                if next.isreg() or next.type not in SUPPORTED_TYPES:
+                    offset += next._block(next.size)
+                tarfile.offset = offset
+
+        return next
+
+    def _proc_gnusparse_00(self, next, pax_headers, buf):
+        """Process a GNU tar extended sparse header, version 0.0.
+        """
+        offsets = []
+        for match in re.finditer(br"\d+ GNU.sparse.offset=(\d+)\n", buf):
+            offsets.append(int(match.group(1)))
+        numbytes = []
+        for match in re.finditer(br"\d+ GNU.sparse.numbytes=(\d+)\n", buf):
+            numbytes.append(int(match.group(1)))
+        next.sparse = list(zip(offsets, numbytes))
+
+    def _proc_gnusparse_01(self, next, pax_headers):
+        """Process a GNU tar extended sparse header, version 0.1.
+        """
+        sparse = [int(x) for x in pax_headers["GNU.sparse.map"].split(",")]
+        next.sparse = list(zip(sparse[::2], sparse[1::2]))
+
+    def _proc_gnusparse_10(self, next, pax_headers, tarfile):
+        """Process a GNU tar extended sparse header, version 1.0.
+        """
+        fields = None
+        sparse = []
+        buf = tarfile.fileobj.read(BLOCKSIZE)
+        fields, buf = buf.split(b"\n", 1)
+        fields = int(fields)
+        while len(sparse) < fields * 2:
+            if b"\n" not in buf:
+                buf += tarfile.fileobj.read(BLOCKSIZE)
+            number, buf = buf.split(b"\n", 1)
+            sparse.append(int(number))
+        next.offset_data = tarfile.fileobj.tell()
+        next.sparse = list(zip(sparse[::2], sparse[1::2]))
+
+    def _apply_pax_info(self, pax_headers, encoding, errors):
+        """Replace fields with supplemental information from a previous
+           pax extended or global header.
+        """
+        for keyword, value in pax_headers.items():
+            if keyword == "GNU.sparse.name":
+                setattr(self, "path", value)
+            elif keyword == "GNU.sparse.size":
+                setattr(self, "size", int(value))
+            elif keyword == "GNU.sparse.realsize":
+                setattr(self, "size", int(value))
+            elif keyword in PAX_FIELDS:
+                if keyword in PAX_NUMBER_FIELDS:
+                    try:
+                        value = PAX_NUMBER_FIELDS[keyword](value)
+                    except ValueError:
+                        value = 0
+                if keyword == "path":
+                    value = value.rstrip("/")
+                setattr(self, keyword, value)
+
+        self.pax_headers = pax_headers.copy()
+
+    def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors):
+        """Decode a single field from a pax record.
+        """
+        try:
+            return value.decode(encoding, "strict")
+        except UnicodeDecodeError:
+            return value.decode(fallback_encoding, fallback_errors)
+
+    def _block(self, count):
+        """Round up a byte count by BLOCKSIZE and return it,
+           e.g. _block(834) => 1024.
+        """
+        blocks, remainder = divmod(count, BLOCKSIZE)
+        if remainder:
+            blocks += 1
+        return blocks * BLOCKSIZE
+
+    def isreg(self):
+        return self.type in REGULAR_TYPES
+    def isfile(self):
+        return self.isreg()
+    def isdir(self):
+        return self.type == DIRTYPE
+    def issym(self):
+        return self.type == SYMTYPE
+    def islnk(self):
+        return self.type == LNKTYPE
+    def ischr(self):
+        return self.type == CHRTYPE
+    def isblk(self):
+        return self.type == BLKTYPE
+    def isfifo(self):
+        return self.type == FIFOTYPE
+    def issparse(self):
+        return self.sparse is not None
+    def isdev(self):
+        return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE)
+# class TarInfo
+
+class TarFile(object):
+    """The TarFile Class provides an interface to tar archives.
+    """
+
+    debug = 0                   # May be set from 0 (no msgs) to 3 (all msgs)
+
+    dereference = False         # If true, add content of linked file to the
+                                # tar file, else the link.
+
+    ignore_zeros = False        # If true, skips empty or invalid blocks and
+                                # continues processing.
+
+    errorlevel = 1              # If 0, fatal errors only appear in debug
+                                # messages (if debug >= 0). If > 0, errors
+                                # are passed to the caller as exceptions.
+
+    format = DEFAULT_FORMAT     # The format to use when creating an archive.
+
+    encoding = ENCODING         # Encoding for 8-bit character strings.
+
+    errors = None               # Error handler for unicode conversion.
+
+    tarinfo = TarInfo           # The default TarInfo class to use.
+
+    fileobject = ExFileObject   # The default ExFileObject class to use.
+
+    def __init__(self, name=None, mode="r", fileobj=None, format=None,
+            tarinfo=None, dereference=None, ignore_zeros=None, encoding=None,
+            errors="surrogateescape", pax_headers=None, debug=None, errorlevel=None):
+        """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
+           read from an existing archive, 'a' to append data to an existing
+           file or 'w' to create a new file overwriting an existing one. `mode'
+           defaults to 'r'.
+           If `fileobj' is given, it is used for reading or writing data. If it
+           can be determined, `mode' is overridden by `fileobj's mode.
+           `fileobj' is not closed, when TarFile is closed.
+        """
+        if len(mode) > 1 or mode not in "raw":
+            raise ValueError("mode must be 'r', 'a' or 'w'")
+        self.mode = mode
+        self._mode = {"r": "rb", "a": "r+b", "w": "wb"}[mode]
+
+        if not fileobj:
+            if self.mode == "a" and not os.path.exists(name):
+                # Create nonexistent files in append mode.
+                self.mode = "w"
+                self._mode = "wb"
+            fileobj = bltn_open(name, self._mode)
+            self._extfileobj = False
+        else:
+            if name is None and hasattr(fileobj, "name"):
+                name = fileobj.name
+            if hasattr(fileobj, "mode"):
+                self._mode = fileobj.mode
+            self._extfileobj = True
+        self.name = os.path.abspath(name) if name else None
+        self.fileobj = fileobj
+
+        # Init attributes.
+        if format is not None:
+            self.format = format
+        if tarinfo is not None:
+            self.tarinfo = tarinfo
+        if dereference is not None:
+            self.dereference = dereference
+        if ignore_zeros is not None:
+            self.ignore_zeros = ignore_zeros
+        if encoding is not None:
+            self.encoding = encoding
+        self.errors = errors
+
+        if pax_headers is not None and self.format == PAX_FORMAT:
+            self.pax_headers = pax_headers
+        else:
+            self.pax_headers = {}
+
+        if debug is not None:
+            self.debug = debug
+        if errorlevel is not None:
+            self.errorlevel = errorlevel
+
+        # Init datastructures.
+        self.closed = False
+        self.members = []       # list of members as TarInfo objects
+        self._loaded = False    # flag if all members have been read
+        self.offset = self.fileobj.tell()
+                                # current position in the archive file
+        self.inodes = {}        # dictionary caching the inodes of
+                                # archive members already added
+
+        try:
+            if self.mode == "r":
+                self.firstmember = None
+                self.firstmember = self.next()
+
+            if self.mode == "a":
+                # Move to the end of the archive,
+                # before the first empty block.
+                while True:
+                    self.fileobj.seek(self.offset)
+                    try:
+                        tarinfo = self.tarinfo.fromtarfile(self)
+                        self.members.append(tarinfo)
+                    except EOFHeaderError:
+                        self.fileobj.seek(self.offset)
+                        break
+                    except HeaderError as e:
+                        raise ReadError(str(e))
+
+            if self.mode in "aw":
+                self._loaded = True
+
+                if self.pax_headers:
+                    buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy())
+                    self.fileobj.write(buf)
+                    self.offset += len(buf)
+        except:
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+            raise
+
+    #--------------------------------------------------------------------------
+    # Below are the classmethods which act as alternate constructors to the
+    # TarFile class. The open() method is the only one that is needed for
+    # public use; it is the "super"-constructor and is able to select an
+    # adequate "sub"-constructor for a particular compression using the mapping
+    # from OPEN_METH.
+    #
+    # This concept allows one to subclass TarFile without losing the comfort of
+    # the super-constructor. A sub-constructor is registered and made available
+    # by adding it to the mapping in OPEN_METH.
+
+    @classmethod
+    def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
+        """Open a tar archive for reading, writing or appending. Return
+           an appropriate TarFile class.
+
+           mode:
+           'r' or 'r:*' open for reading with transparent compression
+           'r:'         open for reading exclusively uncompressed
+           'r:gz'       open for reading with gzip compression
+           'r:bz2'      open for reading with bzip2 compression
+           'a' or 'a:'  open for appending, creating the file if necessary
+           'w' or 'w:'  open for writing without compression
+           'w:gz'       open for writing with gzip compression
+           'w:bz2'      open for writing with bzip2 compression
+
+           'r|*'        open a stream of tar blocks with transparent compression
+           'r|'         open an uncompressed stream of tar blocks for reading
+           'r|gz'       open a gzip compressed stream of tar blocks
+           'r|bz2'      open a bzip2 compressed stream of tar blocks
+           'w|'         open an uncompressed stream for writing
+           'w|gz'       open a gzip compressed stream for writing
+           'w|bz2'      open a bzip2 compressed stream for writing
+        """
+
+        if not name and not fileobj:
+            raise ValueError("nothing to open")
+
+        if mode in ("r", "r:*"):
+            # Find out which *open() is appropriate for opening the file.
+            for comptype in cls.OPEN_METH:
+                func = getattr(cls, cls.OPEN_METH[comptype])
+                if fileobj is not None:
+                    saved_pos = fileobj.tell()
+                try:
+                    return func(name, "r", fileobj, **kwargs)
+                except (ReadError, CompressionError) as e:
+                    if fileobj is not None:
+                        fileobj.seek(saved_pos)
+                    continue
+            raise ReadError("file could not be opened successfully")
+
+        elif ":" in mode:
+            filemode, comptype = mode.split(":", 1)
+            filemode = filemode or "r"
+            comptype = comptype or "tar"
+
+            # Select the *open() function according to
+            # given compression.
+            if comptype in cls.OPEN_METH:
+                func = getattr(cls, cls.OPEN_METH[comptype])
+            else:
+                raise CompressionError("unknown compression type %r" % comptype)
+            return func(name, filemode, fileobj, **kwargs)
+
+        elif "|" in mode:
+            filemode, comptype = mode.split("|", 1)
+            filemode = filemode or "r"
+            comptype = comptype or "tar"
+
+            if filemode not in "rw":
+                raise ValueError("mode must be 'r' or 'w'")
+
+            stream = _Stream(name, filemode, comptype, fileobj, bufsize)
+            try:
+                t = cls(name, filemode, stream, **kwargs)
+            except:
+                stream.close()
+                raise
+            t._extfileobj = False
+            return t
+
+        elif mode in "aw":
+            return cls.taropen(name, mode, fileobj, **kwargs)
+
+        raise ValueError("undiscernible mode")
+
+    @classmethod
+    def taropen(cls, name, mode="r", fileobj=None, **kwargs):
+        """Open uncompressed tar archive name for reading or writing.
+        """
+        if len(mode) > 1 or mode not in "raw":
+            raise ValueError("mode must be 'r', 'a' or 'w'")
+        return cls(name, mode, fileobj, **kwargs)
+
+    @classmethod
+    def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
+        """Open gzip compressed tar archive name for reading or writing.
+           Appending is not allowed.
+        """
+        if len(mode) > 1 or mode not in "rw":
+            raise ValueError("mode must be 'r' or 'w'")
+
+        try:
+            import gzip
+            gzip.GzipFile
+        except (ImportError, AttributeError):
+            raise CompressionError("gzip module is not available")
+
+        extfileobj = fileobj is not None
+        try:
+            fileobj = gzip.GzipFile(name, mode + "b", compresslevel, fileobj)
+            t = cls.taropen(name, mode, fileobj, **kwargs)
+        except IOError:
+            if not extfileobj and fileobj is not None:
+                fileobj.close()
+            if fileobj is None:
+                raise
+            raise ReadError("not a gzip file")
+        except:
+            if not extfileobj and fileobj is not None:
+                fileobj.close()
+            raise
+        t._extfileobj = extfileobj
+        return t
+
+    @classmethod
+    def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
+        """Open bzip2 compressed tar archive name for reading or writing.
+           Appending is not allowed.
+        """
+        if len(mode) > 1 or mode not in "rw":
+            raise ValueError("mode must be 'r' or 'w'.")
+
+        try:
+            import bz2
+        except ImportError:
+            raise CompressionError("bz2 module is not available")
+
+        if fileobj is not None:
+            fileobj = _BZ2Proxy(fileobj, mode)
+        else:
+            fileobj = bz2.BZ2File(name, mode, compresslevel=compresslevel)
+
+        try:
+            t = cls.taropen(name, mode, fileobj, **kwargs)
+        except (IOError, EOFError):
+            fileobj.close()
+            raise ReadError("not a bzip2 file")
+        t._extfileobj = False
+        return t
+
+    # All *open() methods are registered here.
+    OPEN_METH = {
+        "tar": "taropen",   # uncompressed tar
+        "gz":  "gzopen",    # gzip compressed tar
+        "bz2": "bz2open"    # bzip2 compressed tar
+    }
+
+    #--------------------------------------------------------------------------
+    # The public methods which TarFile provides:
+
+    def close(self):
+        """Close the TarFile. In write-mode, two finishing zero blocks are
+           appended to the archive.
+        """
+        if self.closed:
+            return
+
+        if self.mode in "aw":
+            self.fileobj.write(NUL * (BLOCKSIZE * 2))
+            self.offset += (BLOCKSIZE * 2)
+            # fill up the end with zero-blocks
+            # (like option -b20 for tar does)
+            blocks, remainder = divmod(self.offset, RECORDSIZE)
+            if remainder > 0:
+                self.fileobj.write(NUL * (RECORDSIZE - remainder))
+
+        if not self._extfileobj:
+            self.fileobj.close()
+        self.closed = True
+
+    def getmember(self, name):
+        """Return a TarInfo object for member `name'. If `name' can not be
+           found in the archive, KeyError is raised. If a member occurs more
+           than once in the archive, its last occurrence is assumed to be the
+           most up-to-date version.
+        """
+        tarinfo = self._getmember(name)
+        if tarinfo is None:
+            raise KeyError("filename %r not found" % name)
+        return tarinfo
+
+    def getmembers(self):
+        """Return the members of the archive as a list of TarInfo objects. The
+           list has the same order as the members in the archive.
+        """
+        self._check()
+        if not self._loaded:    # if we want to obtain a list of
+            self._load()        # all members, we first have to
+                                # scan the whole archive.
+        return self.members
+
+    def getnames(self):
+        """Return the members of the archive as a list of their names. It has
+           the same order as the list returned by getmembers().
+        """
+        return [tarinfo.name for tarinfo in self.getmembers()]
+
+    def gettarinfo(self, name=None, arcname=None, fileobj=None):
+        """Create a TarInfo object for either the file `name' or the file
+           object `fileobj' (using os.fstat on its file descriptor). You can
+           modify some of the TarInfo's attributes before you add it using
+           addfile(). If given, `arcname' specifies an alternative name for the
+           file in the archive.
+        """
+        self._check("aw")
+
+        # When fileobj is given, replace name by
+        # fileobj's real name.
+        if fileobj is not None:
+            name = fileobj.name
+
+        # Building the name of the member in the archive.
+        # Backward slashes are converted to forward slashes,
+        # Absolute paths are turned to relative paths.
+        if arcname is None:
+            arcname = name
+        drv, arcname = os.path.splitdrive(arcname)
+        arcname = arcname.replace(os.sep, "/")
+        arcname = arcname.lstrip("/")
+
+        # Now, fill the TarInfo object with
+        # information specific for the file.
+        tarinfo = self.tarinfo()
+        tarinfo.tarfile = self
+
+        # Use os.stat or os.lstat, depending on platform
+        # and if symlinks shall be resolved.
+        if fileobj is None:
+            if hasattr(os, "lstat") and not self.dereference:
+                statres = os.lstat(name)
+            else:
+                statres = os.stat(name)
+        else:
+            statres = os.fstat(fileobj.fileno())
+        linkname = ""
+
+        stmd = statres.st_mode
+        if stat.S_ISREG(stmd):
+            inode = (statres.st_ino, statres.st_dev)
+            if not self.dereference and statres.st_nlink > 1 and \
+                    inode in self.inodes and arcname != self.inodes[inode]:
+                # Is it a hardlink to an already
+                # archived file?
+                type = LNKTYPE
+                linkname = self.inodes[inode]
+            else:
+                # The inode is added only if its valid.
+                # For win32 it is always 0.
+                type = REGTYPE
+                if inode[0]:
+                    self.inodes[inode] = arcname
+        elif stat.S_ISDIR(stmd):
+            type = DIRTYPE
+        elif stat.S_ISFIFO(stmd):
+            type = FIFOTYPE
+        elif stat.S_ISLNK(stmd):
+            type = SYMTYPE
+            linkname = os.readlink(name)
+        elif stat.S_ISCHR(stmd):
+            type = CHRTYPE
+        elif stat.S_ISBLK(stmd):
+            type = BLKTYPE
+        else:
+            return None
+
+        # Fill the TarInfo object with all
+        # information we can get.
+        tarinfo.name = arcname
+        tarinfo.mode = stmd
+        tarinfo.uid = statres.st_uid
+        tarinfo.gid = statres.st_gid
+        if type == REGTYPE:
+            tarinfo.size = statres.st_size
+        else:
+            tarinfo.size = 0
+        tarinfo.mtime = statres.st_mtime
+        tarinfo.type = type
+        tarinfo.linkname = linkname
+        if pwd:
+            try:
+                tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
+            except KeyError:
+                pass
+        if grp:
+            try:
+                tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
+            except KeyError:
+                pass
+
+        if type in (CHRTYPE, BLKTYPE):
+            if hasattr(os, "major") and hasattr(os, "minor"):
+                tarinfo.devmajor = os.major(statres.st_rdev)
+                tarinfo.devminor = os.minor(statres.st_rdev)
+        return tarinfo
+
+    def list(self, verbose=True):
+        """Print a table of contents to sys.stdout. If `verbose' is False, only
+           the names of the members are printed. If it is True, an `ls -l'-like
+           output is produced.
+        """
+        self._check()
+
+        for tarinfo in self:
+            if verbose:
+                print(filemode(tarinfo.mode), end=' ')
+                print("%s/%s" % (tarinfo.uname or tarinfo.uid,
+                                 tarinfo.gname or tarinfo.gid), end=' ')
+                if tarinfo.ischr() or tarinfo.isblk():
+                    print("%10s" % ("%d,%d" \
+                                    % (tarinfo.devmajor, tarinfo.devminor)), end=' ')
+                else:
+                    print("%10d" % tarinfo.size, end=' ')
+                print("%d-%02d-%02d %02d:%02d:%02d" \
+                      % time.localtime(tarinfo.mtime)[:6], end=' ')
+
+            print(tarinfo.name + ("/" if tarinfo.isdir() else ""), end=' ')
+
+            if verbose:
+                if tarinfo.issym():
+                    print("->", tarinfo.linkname, end=' ')
+                if tarinfo.islnk():
+                    print("link to", tarinfo.linkname, end=' ')
+            print()
+
+    def add(self, name, arcname=None, recursive=True, exclude=None, filter=None):
+        """Add the file `name' to the archive. `name' may be any type of file
+           (directory, fifo, symbolic link, etc.). If given, `arcname'
+           specifies an alternative name for the file in the archive.
+           Directories are added recursively by default. This can be avoided by
+           setting `recursive' to False. `exclude' is a function that should
+           return True for each filename to be excluded. `filter' is a function
+           that expects a TarInfo object argument and returns the changed
+           TarInfo object, if it returns None the TarInfo object will be
+           excluded from the archive.
+        """
+        self._check("aw")
+
+        if arcname is None:
+            arcname = name
+
+        # Exclude pathnames.
+        if exclude is not None:
+            import warnings
+            warnings.warn("use the filter argument instead",
+                    DeprecationWarning, 2)
+            if exclude(name):
+                self._dbg(2, "tarfile: Excluded %r" % name)
+                return
+
+        # Skip if somebody tries to archive the archive...
+        if self.name is not None and os.path.abspath(name) == self.name:
+            self._dbg(2, "tarfile: Skipped %r" % name)
+            return
+
+        self._dbg(1, name)
+
+        # Create a TarInfo object from the file.
+        tarinfo = self.gettarinfo(name, arcname)
+
+        if tarinfo is None:
+            self._dbg(1, "tarfile: Unsupported type %r" % name)
+            return
+
+        # Change or exclude the TarInfo object.
+        if filter is not None:
+            tarinfo = filter(tarinfo)
+            if tarinfo is None:
+                self._dbg(2, "tarfile: Excluded %r" % name)
+                return
+
+        # Append the tar header and data to the archive.
+        if tarinfo.isreg():
+            f = bltn_open(name, "rb")
+            self.addfile(tarinfo, f)
+            f.close()
+
+        elif tarinfo.isdir():
+            self.addfile(tarinfo)
+            if recursive:
+                for f in os.listdir(name):
+                    self.add(os.path.join(name, f), os.path.join(arcname, f),
+                            recursive, exclude, filter=filter)
+
+        else:
+            self.addfile(tarinfo)
+
+    def addfile(self, tarinfo, fileobj=None):
+        """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
+           given, tarinfo.size bytes are read from it and added to the archive.
+           You can create TarInfo objects using gettarinfo().
+           On Windows platforms, `fileobj' should always be opened with mode
+           'rb' to avoid irritation about the file size.
+        """
+        self._check("aw")
+
+        tarinfo = copy.copy(tarinfo)
+
+        buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
+        self.fileobj.write(buf)
+        self.offset += len(buf)
+
+        # If there's data to follow, append it.
+        if fileobj is not None:
+            copyfileobj(fileobj, self.fileobj, tarinfo.size)
+            blocks, remainder = divmod(tarinfo.size, BLOCKSIZE)
+            if remainder > 0:
+                self.fileobj.write(NUL * (BLOCKSIZE - remainder))
+                blocks += 1
+            self.offset += blocks * BLOCKSIZE
+
+        self.members.append(tarinfo)
+
+    def extractall(self, path=".", members=None):
+        """Extract all members from the archive to the current working
+           directory and set owner, modification time and permissions on
+           directories afterwards. `path' specifies a different directory
+           to extract to. `members' is optional and must be a subset of the
+           list returned by getmembers().
+        """
+        directories = []
+
+        if members is None:
+            members = self
+
+        for tarinfo in members:
+            if tarinfo.isdir():
+                # Extract directories with a safe mode.
+                directories.append(tarinfo)
+                tarinfo = copy.copy(tarinfo)
+                tarinfo.mode = 0o700
+            # Do not set_attrs directories, as we will do that further down
+            self.extract(tarinfo, path, set_attrs=not tarinfo.isdir())
+
+        # Reverse sort directories.
+        directories.sort(key=lambda a: a.name)
+        directories.reverse()
+
+        # Set correct owner, mtime and filemode on directories.
+        for tarinfo in directories:
+            dirpath = os.path.join(path, tarinfo.name)
+            try:
+                self.chown(tarinfo, dirpath)
+                self.utime(tarinfo, dirpath)
+                self.chmod(tarinfo, dirpath)
+            except ExtractError as e:
+                if self.errorlevel > 1:
+                    raise
+                else:
+                    self._dbg(1, "tarfile: %s" % e)
+
+    def extract(self, member, path="", set_attrs=True):
+        """Extract a member from the archive to the current working directory,
+           using its full name. Its file information is extracted as accurately
+           as possible. `member' may be a filename or a TarInfo object. You can
+           specify a different directory using `path'. File attributes (owner,
+           mtime, mode) are set unless `set_attrs' is False.
+        """
+        self._check("r")
+
+        if isinstance(member, str):
+            tarinfo = self.getmember(member)
+        else:
+            tarinfo = member
+
+        # Prepare the link target for makelink().
+        if tarinfo.islnk():
+            tarinfo._link_target = os.path.join(path, tarinfo.linkname)
+
+        try:
+            self._extract_member(tarinfo, os.path.join(path, tarinfo.name),
+                                 set_attrs=set_attrs)
+        except EnvironmentError as e:
+            if self.errorlevel > 0:
+                raise
+            else:
+                if e.filename is None:
+                    self._dbg(1, "tarfile: %s" % e.strerror)
+                else:
+                    self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename))
+        except ExtractError as e:
+            if self.errorlevel > 1:
+                raise
+            else:
+                self._dbg(1, "tarfile: %s" % e)
+
+    def extractfile(self, member):
+        """Extract a member from the archive as a file object. `member' may be
+           a filename or a TarInfo object. If `member' is a regular file, a
+           file-like object is returned. If `member' is a link, a file-like
+           object is constructed from the link's target. If `member' is none of
+           the above, None is returned.
+           The file-like object is read-only and provides the following
+           methods: read(), readline(), readlines(), seek() and tell()
+        """
+        self._check("r")
+
+        if isinstance(member, str):
+            tarinfo = self.getmember(member)
+        else:
+            tarinfo = member
+
+        if tarinfo.isreg():
+            return self.fileobject(self, tarinfo)
+
+        elif tarinfo.type not in SUPPORTED_TYPES:
+            # If a member's type is unknown, it is treated as a
+            # regular file.
+            return self.fileobject(self, tarinfo)
+
+        elif tarinfo.islnk() or tarinfo.issym():
+            if isinstance(self.fileobj, _Stream):
+                # A small but ugly workaround for the case that someone tries
+                # to extract a (sym)link as a file-object from a non-seekable
+                # stream of tar blocks.
+                raise StreamError("cannot extract (sym)link as file object")
+            else:
+                # A (sym)link's file object is its target's file object.
+                return self.extractfile(self._find_link_target(tarinfo))
+        else:
+            # If there's no data associated with the member (directory, chrdev,
+            # blkdev, etc.), return None instead of a file object.
+            return None
+
+    def _extract_member(self, tarinfo, targetpath, set_attrs=True):
+        """Extract the TarInfo object tarinfo to a physical
+           file called targetpath.
+        """
+        # Fetch the TarInfo object for the given name
+        # and build the destination pathname, replacing
+        # forward slashes to platform specific separators.
+        targetpath = targetpath.rstrip("/")
+        targetpath = targetpath.replace("/", os.sep)
+
+        # Create all upper directories.
+        upperdirs = os.path.dirname(targetpath)
+        if upperdirs and not os.path.exists(upperdirs):
+            # Create directories that are not part of the archive with
+            # default permissions.
+            os.makedirs(upperdirs)
+
+        if tarinfo.islnk() or tarinfo.issym():
+            self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
+        else:
+            self._dbg(1, tarinfo.name)
+
+        if tarinfo.isreg():
+            self.makefile(tarinfo, targetpath)
+        elif tarinfo.isdir():
+            self.makedir(tarinfo, targetpath)
+        elif tarinfo.isfifo():
+            self.makefifo(tarinfo, targetpath)
+        elif tarinfo.ischr() or tarinfo.isblk():
+            self.makedev(tarinfo, targetpath)
+        elif tarinfo.islnk() or tarinfo.issym():
+            self.makelink(tarinfo, targetpath)
+        elif tarinfo.type not in SUPPORTED_TYPES:
+            self.makeunknown(tarinfo, targetpath)
+        else:
+            self.makefile(tarinfo, targetpath)
+
+        if set_attrs:
+            self.chown(tarinfo, targetpath)
+            if not tarinfo.issym():
+                self.chmod(tarinfo, targetpath)
+                self.utime(tarinfo, targetpath)
+
+    #--------------------------------------------------------------------------
+    # Below are the different file methods. They are called via
+    # _extract_member() when extract() is called. They can be replaced in a
+    # subclass to implement other functionality.
+
+    def makedir(self, tarinfo, targetpath):
+        """Make a directory called targetpath.
+        """
+        try:
+            # Use a safe mode for the directory, the real mode is set
+            # later in _extract_member().
+            os.mkdir(targetpath, 0o700)
+        except EnvironmentError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+    def makefile(self, tarinfo, targetpath):
+        """Make a file called targetpath.
+        """
+        source = self.fileobj
+        source.seek(tarinfo.offset_data)
+        target = bltn_open(targetpath, "wb")
+        if tarinfo.sparse is not None:
+            for offset, size in tarinfo.sparse:
+                target.seek(offset)
+                copyfileobj(source, target, size)
+        else:
+            copyfileobj(source, target, tarinfo.size)
+        target.seek(tarinfo.size)
+        target.truncate()
+        target.close()
+
+    def makeunknown(self, tarinfo, targetpath):
+        """Make a file from a TarInfo object with an unknown type
+           at targetpath.
+        """
+        self.makefile(tarinfo, targetpath)
+        self._dbg(1, "tarfile: Unknown file type %r, " \
+                     "extracted as regular file." % tarinfo.type)
+
+    def makefifo(self, tarinfo, targetpath):
+        """Make a fifo called targetpath.
+        """
+        if hasattr(os, "mkfifo"):
+            os.mkfifo(targetpath)
+        else:
+            raise ExtractError("fifo not supported by system")
+
+    def makedev(self, tarinfo, targetpath):
+        """Make a character or block device called targetpath.
+        """
+        if not hasattr(os, "mknod") or not hasattr(os, "makedev"):
+            raise ExtractError("special devices not supported by system")
+
+        mode = tarinfo.mode
+        if tarinfo.isblk():
+            mode |= stat.S_IFBLK
+        else:
+            mode |= stat.S_IFCHR
+
+        os.mknod(targetpath, mode,
+                 os.makedev(tarinfo.devmajor, tarinfo.devminor))
+
+    def makelink(self, tarinfo, targetpath):
+        """Make a (symbolic) link called targetpath. If it cannot be created
+          (platform limitation), we try to make a copy of the referenced file
+          instead of a link.
+        """
+        try:
+            # For systems that support symbolic and hard links.
+            if tarinfo.issym():
+                os.symlink(tarinfo.linkname, targetpath)
+            else:
+                # See extract().
+                if os.path.exists(tarinfo._link_target):
+                    os.link(tarinfo._link_target, targetpath)
+                else:
+                    self._extract_member(self._find_link_target(tarinfo),
+                                         targetpath)
+        except symlink_exception:
+            if tarinfo.issym():
+                linkpath = os.path.join(os.path.dirname(tarinfo.name),
+                                        tarinfo.linkname)
+            else:
+                linkpath = tarinfo.linkname
+        else:
+            try:
+                self._extract_member(self._find_link_target(tarinfo),
+                                     targetpath)
+            except KeyError:
+                raise ExtractError("unable to resolve link inside archive")
+
+    def chown(self, tarinfo, targetpath):
+        """Set owner of targetpath according to tarinfo.
+        """
+        if pwd and hasattr(os, "geteuid") and os.geteuid() == 0:
+            # We have to be root to do so.
+            try:
+                g = grp.getgrnam(tarinfo.gname)[2]
+            except KeyError:
+                g = tarinfo.gid
+            try:
+                u = pwd.getpwnam(tarinfo.uname)[2]
+            except KeyError:
+                u = tarinfo.uid
+            try:
+                if tarinfo.issym() and hasattr(os, "lchown"):
+                    os.lchown(targetpath, u, g)
+                else:
+                    if sys.platform != "os2emx":
+                        os.chown(targetpath, u, g)
+            except EnvironmentError as e:
+                raise ExtractError("could not change owner")
+
+    def chmod(self, tarinfo, targetpath):
+        """Set file permissions of targetpath according to tarinfo.
+        """
+        if hasattr(os, 'chmod'):
+            try:
+                os.chmod(targetpath, tarinfo.mode)
+            except EnvironmentError as e:
+                raise ExtractError("could not change mode")
+
+    def utime(self, tarinfo, targetpath):
+        """Set modification time of targetpath according to tarinfo.
+        """
+        if not hasattr(os, 'utime'):
+            return
+        try:
+            os.utime(targetpath, (tarinfo.mtime, tarinfo.mtime))
+        except EnvironmentError as e:
+            raise ExtractError("could not change modification time")
+
+    #--------------------------------------------------------------------------
+    def next(self):
+        """Return the next member of the archive as a TarInfo object, when
+           TarFile is opened for reading. Return None if there is no more
+           available.
+        """
+        self._check("ra")
+        if self.firstmember is not None:
+            m = self.firstmember
+            self.firstmember = None
+            return m
+
+        # Read the next block.
+        self.fileobj.seek(self.offset)
+        tarinfo = None
+        while True:
+            try:
+                tarinfo = self.tarinfo.fromtarfile(self)
+            except EOFHeaderError as e:
+                if self.ignore_zeros:
+                    self._dbg(2, "0x%X: %s" % (self.offset, e))
+                    self.offset += BLOCKSIZE
+                    continue
+            except InvalidHeaderError as e:
+                if self.ignore_zeros:
+                    self._dbg(2, "0x%X: %s" % (self.offset, e))
+                    self.offset += BLOCKSIZE
+                    continue
+                elif self.offset == 0:
+                    raise ReadError(str(e))
+            except EmptyHeaderError:
+                if self.offset == 0:
+                    raise ReadError("empty file")
+            except TruncatedHeaderError as e:
+                if self.offset == 0:
+                    raise ReadError(str(e))
+            except SubsequentHeaderError as e:
+                raise ReadError(str(e))
+            break
+
+        if tarinfo is not None:
+            self.members.append(tarinfo)
+        else:
+            self._loaded = True
+
+        return tarinfo
+
+    #--------------------------------------------------------------------------
+    # Little helper methods:
+
+    def _getmember(self, name, tarinfo=None, normalize=False):
+        """Find an archive member by name from bottom to top.
+           If tarinfo is given, it is used as the starting point.
+        """
+        # Ensure that all members have been loaded.
+        members = self.getmembers()
+
+        # Limit the member search list up to tarinfo.
+        if tarinfo is not None:
+            members = members[:members.index(tarinfo)]
+
+        if normalize:
+            name = os.path.normpath(name)
+
+        for member in reversed(members):
+            if normalize:
+                member_name = os.path.normpath(member.name)
+            else:
+                member_name = member.name
+
+            if name == member_name:
+                return member
+
+    def _load(self):
+        """Read through the entire archive file and look for readable
+           members.
+        """
+        while True:
+            tarinfo = self.next()
+            if tarinfo is None:
+                break
+        self._loaded = True
+
+    def _check(self, mode=None):
+        """Check if TarFile is still open, and if the operation's mode
+           corresponds to TarFile's mode.
+        """
+        if self.closed:
+            raise IOError("%s is closed" % self.__class__.__name__)
+        if mode is not None and self.mode not in mode:
+            raise IOError("bad operation for mode %r" % self.mode)
+
+    def _find_link_target(self, tarinfo):
+        """Find the target member of a symlink or hardlink member in the
+           archive.
+        """
+        if tarinfo.issym():
+            # Always search the entire archive.
+            linkname = os.path.dirname(tarinfo.name) + "/" + tarinfo.linkname
+            limit = None
+        else:
+            # Search the archive before the link, because a hard link is
+            # just a reference to an already archived file.
+            linkname = tarinfo.linkname
+            limit = tarinfo
+
+        member = self._getmember(linkname, tarinfo=limit, normalize=True)
+        if member is None:
+            raise KeyError("linkname %r not found" % linkname)
+        return member
+
+    def __iter__(self):
+        """Provide an iterator object.
+        """
+        if self._loaded:
+            return iter(self.members)
+        else:
+            return TarIter(self)
+
+    def _dbg(self, level, msg):
+        """Write debugging output to sys.stderr.
+        """
+        if level <= self.debug:
+            print(msg, file=sys.stderr)
+
+    def __enter__(self):
+        self._check()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            self.close()
+        else:
+            # An exception occurred. We must not call close() because
+            # it would try to write end-of-archive blocks and padding.
+            if not self._extfileobj:
+                self.fileobj.close()
+            self.closed = True
+# class TarFile
+
+class TarIter(object):
+    """Iterator Class.
+
+       for tarinfo in TarFile(...):
+           suite...
+    """
+
+    def __init__(self, tarfile):
+        """Construct a TarIter object.
+        """
+        self.tarfile = tarfile
+        self.index = 0
+    def __iter__(self):
+        """Return iterator object.
+        """
+        return self
+
+    def __next__(self):
+        """Return the next item using TarFile's next() method.
+           When all members have been read, set TarFile as _loaded.
+        """
+        # Fix for SF #1100429: Under rare circumstances it can
+        # happen that getmembers() is called during iteration,
+        # which will cause TarIter to stop prematurely.
+        if not self.tarfile._loaded:
+            tarinfo = self.tarfile.next()
+            if not tarinfo:
+                self.tarfile._loaded = True
+                raise StopIteration
+        else:
+            try:
+                tarinfo = self.tarfile.members[self.index]
+            except IndexError:
+                raise StopIteration
+        self.index += 1
+        return tarinfo
+
+    next = __next__ # for Python 2.x
+
+#--------------------
+# exported functions
+#--------------------
+def is_tarfile(name):
+    """Return True if name points to a tar archive that we
+       are able to handle, else return False.
+    """
+    try:
+        t = open(name)
+        t.close()
+        return True
+    except TarError:
+        return False
+
+bltn_open = open
+open = TarFile.open
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/t32.exe b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/t32.exe
new file mode 100644
index 0000000000000000000000000000000000000000..5d5bce1f4a65f0bea9636a5a825646c520903df4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/t32.exe differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/util.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e851146c0f3b3db0947629a1b7aea717d53e978c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/util.py
@@ -0,0 +1,1760 @@
+#
+# Copyright (C) 2012-2017 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import codecs
+from collections import deque
+import contextlib
+import csv
+from glob import iglob as std_iglob
+import io
+import json
+import logging
+import os
+import py_compile
+import re
+import socket
+try:
+    import ssl
+except ImportError:  # pragma: no cover
+    ssl = None
+import subprocess
+import sys
+import tarfile
+import tempfile
+import textwrap
+
+try:
+    import threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as threading
+import time
+
+from . import DistlibException
+from .compat import (string_types, text_type, shutil, raw_input, StringIO,
+                     cache_from_source, urlopen, urljoin, httplib, xmlrpclib,
+                     splittype, HTTPHandler, BaseConfigurator, valid_ident,
+                     Container, configparser, URLError, ZipFile, fsdecode,
+                     unquote, urlparse)
+
+logger = logging.getLogger(__name__)
+
+#
+# Requirement parsing code as per PEP 508
+#
+
+IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')
+VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')
+COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')
+MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')
+OR = re.compile(r'^or\b\s*')
+AND = re.compile(r'^and\b\s*')
+NON_SPACE = re.compile(r'(\S+)\s*')
+STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')
+
+
+def parse_marker(marker_string):
+    """
+    Parse a marker string and return a dictionary containing a marker expression.
+
+    The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
+    the expression grammar, or strings. A string contained in quotes is to be
+    interpreted as a literal string, and a string not contained in quotes is a
+    variable (such as os_name).
+    """
+    def marker_var(remaining):
+        # either identifier, or literal string
+        m = IDENTIFIER.match(remaining)
+        if m:
+            result = m.groups()[0]
+            remaining = remaining[m.end():]
+        elif not remaining:
+            raise SyntaxError('unexpected end of input')
+        else:
+            q = remaining[0]
+            if q not in '\'"':
+                raise SyntaxError('invalid expression: %s' % remaining)
+            oq = '\'"'.replace(q, '')
+            remaining = remaining[1:]
+            parts = [q]
+            while remaining:
+                # either a string chunk, or oq, or q to terminate
+                if remaining[0] == q:
+                    break
+                elif remaining[0] == oq:
+                    parts.append(oq)
+                    remaining = remaining[1:]
+                else:
+                    m = STRING_CHUNK.match(remaining)
+                    if not m:
+                        raise SyntaxError('error in string literal: %s' % remaining)
+                    parts.append(m.groups()[0])
+                    remaining = remaining[m.end():]
+            else:
+                s = ''.join(parts)
+                raise SyntaxError('unterminated string: %s' % s)
+            parts.append(q)
+            result = ''.join(parts)
+            remaining = remaining[1:].lstrip() # skip past closing quote
+        return result, remaining
+
+    def marker_expr(remaining):
+        if remaining and remaining[0] == '(':
+            result, remaining = marker(remaining[1:].lstrip())
+            if remaining[0] != ')':
+                raise SyntaxError('unterminated parenthesis: %s' % remaining)
+            remaining = remaining[1:].lstrip()
+        else:
+            lhs, remaining = marker_var(remaining)
+            while remaining:
+                m = MARKER_OP.match(remaining)
+                if not m:
+                    break
+                op = m.groups()[0]
+                remaining = remaining[m.end():]
+                rhs, remaining = marker_var(remaining)
+                lhs = {'op': op, 'lhs': lhs, 'rhs': rhs}
+            result = lhs
+        return result, remaining
+
+    def marker_and(remaining):
+        lhs, remaining = marker_expr(remaining)
+        while remaining:
+            m = AND.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_expr(remaining)
+            lhs = {'op': 'and', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    def marker(remaining):
+        lhs, remaining = marker_and(remaining)
+        while remaining:
+            m = OR.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_and(remaining)
+            lhs = {'op': 'or', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    return marker(marker_string)
+
+
+def parse_requirement(req):
+    """
+    Parse a requirement passed in as a string. Return a Container
+    whose attributes contain the various parts of the requirement.
+    """
+    remaining = req.strip()
+    if not remaining or remaining.startswith('#'):
+        return None
+    m = IDENTIFIER.match(remaining)
+    if not m:
+        raise SyntaxError('name expected: %s' % remaining)
+    distname = m.groups()[0]
+    remaining = remaining[m.end():]
+    extras = mark_expr = versions = uri = None
+    if remaining and remaining[0] == '[':
+        i = remaining.find(']', 1)
+        if i < 0:
+            raise SyntaxError('unterminated extra: %s' % remaining)
+        s = remaining[1:i]
+        remaining = remaining[i + 1:].lstrip()
+        extras = []
+        while s:
+            m = IDENTIFIER.match(s)
+            if not m:
+                raise SyntaxError('malformed extra: %s' % s)
+            extras.append(m.groups()[0])
+            s = s[m.end():]
+            if not s:
+                break
+            if s[0] != ',':
+                raise SyntaxError('comma expected in extras: %s' % s)
+            s = s[1:].lstrip()
+        if not extras:
+            extras = None
+    if remaining:
+        if remaining[0] == '@':
+            # it's a URI
+            remaining = remaining[1:].lstrip()
+            m = NON_SPACE.match(remaining)
+            if not m:
+                raise SyntaxError('invalid URI: %s' % remaining)
+            uri = m.groups()[0]
+            t = urlparse(uri)
+            # there are issues with Python and URL parsing, so this test
+            # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
+            # always parse invalid URLs correctly - it should raise
+            # exceptions for malformed URLs
+            if not (t.scheme and t.netloc):
+                raise SyntaxError('Invalid URL: %s' % uri)
+            remaining = remaining[m.end():].lstrip()
+        else:
+
+            def get_versions(ver_remaining):
+                """
+                Return a list of operator, version tuples if any are
+                specified, else None.
+                """
+                m = COMPARE_OP.match(ver_remaining)
+                versions = None
+                if m:
+                    versions = []
+                    while True:
+                        op = m.groups()[0]
+                        ver_remaining = ver_remaining[m.end():]
+                        m = VERSION_IDENTIFIER.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid version: %s' % ver_remaining)
+                        v = m.groups()[0]
+                        versions.append((op, v))
+                        ver_remaining = ver_remaining[m.end():]
+                        if not ver_remaining or ver_remaining[0] != ',':
+                            break
+                        ver_remaining = ver_remaining[1:].lstrip()
+                        m = COMPARE_OP.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid constraint: %s' % ver_remaining)
+                    if not versions:
+                        versions = None
+                return versions, ver_remaining
+
+            if remaining[0] != '(':
+                versions, remaining = get_versions(remaining)
+            else:
+                i = remaining.find(')', 1)
+                if i < 0:
+                    raise SyntaxError('unterminated parenthesis: %s' % remaining)
+                s = remaining[1:i]
+                remaining = remaining[i + 1:].lstrip()
+                # As a special diversion from PEP 508, allow a version number
+                # a.b.c in parentheses as a synonym for ~= a.b.c (because this
+                # is allowed in earlier PEPs)
+                if COMPARE_OP.match(s):
+                    versions, _ = get_versions(s)
+                else:
+                    m = VERSION_IDENTIFIER.match(s)
+                    if not m:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    v = m.groups()[0]
+                    s = s[m.end():].lstrip()
+                    if s:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    versions = [('~=', v)]
+
+    if remaining:
+        if remaining[0] != ';':
+            raise SyntaxError('invalid requirement: %s' % remaining)
+        remaining = remaining[1:].lstrip()
+
+        mark_expr, remaining = parse_marker(remaining)
+
+    if remaining and remaining[0] != '#':
+        raise SyntaxError('unexpected trailing data: %s' % remaining)
+
+    if not versions:
+        rs = distname
+    else:
+        rs = '%s %s' % (distname, ', '.join(['%s %s' % con for con in versions]))
+    return Container(name=distname, extras=extras, constraints=versions,
+                     marker=mark_expr, url=uri, requirement=rs)
+
+
+def get_resources_dests(resources_root, rules):
+    """Find destinations for resources files"""
+
+    def get_rel_path(root, path):
+        # normalizes and returns a lstripped-/-separated path
+        root = root.replace(os.path.sep, '/')
+        path = path.replace(os.path.sep, '/')
+        assert path.startswith(root)
+        return path[len(root):].lstrip('/')
+
+    destinations = {}
+    for base, suffix, dest in rules:
+        prefix = os.path.join(resources_root, base)
+        for abs_base in iglob(prefix):
+            abs_glob = os.path.join(abs_base, suffix)
+            for abs_path in iglob(abs_glob):
+                resource_file = get_rel_path(resources_root, abs_path)
+                if dest is None:  # remove the entry if it was here
+                    destinations.pop(resource_file, None)
+                else:
+                    rel_path = get_rel_path(abs_base, abs_path)
+                    rel_dest = dest.replace(os.path.sep, '/').rstrip('/')
+                    destinations[resource_file] = rel_dest + '/' + rel_path
+    return destinations
+
+
+def in_venv():
+    if hasattr(sys, 'real_prefix'):
+        # virtualenv venvs
+        result = True
+    else:
+        # PEP 405 venvs
+        result = sys.prefix != getattr(sys, 'base_prefix', sys.prefix)
+    return result
+
+
+def get_executable():
+# The __PYVENV_LAUNCHER__ dance is apparently no longer needed, as
+# changes to the stub launcher mean that sys.executable always points
+# to the stub on OS X
+#    if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
+#                                     in os.environ):
+#        result =  os.environ['__PYVENV_LAUNCHER__']
+#    else:
+#        result = sys.executable
+#    return result
+    result = os.path.normcase(sys.executable)
+    if not isinstance(result, text_type):
+        result = fsdecode(result)
+    return result
+
+
+def proceed(prompt, allowed_chars, error_prompt=None, default=None):
+    p = prompt
+    while True:
+        s = raw_input(p)
+        p = prompt
+        if not s and default:
+            s = default
+        if s:
+            c = s[0].lower()
+            if c in allowed_chars:
+                break
+            if error_prompt:
+                p = '%c: %s\n%s' % (c, error_prompt, prompt)
+    return c
+
+
+def extract_by_key(d, keys):
+    if isinstance(keys, string_types):
+        keys = keys.split()
+    result = {}
+    for key in keys:
+        if key in d:
+            result[key] = d[key]
+    return result
+
+def read_exports(stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getreader('utf-8')(stream)
+    # Try to load as JSON, falling back on legacy format
+    data = stream.read()
+    stream = StringIO(data)
+    try:
+        jdata = json.load(stream)
+        result = jdata['extensions']['python.exports']['exports']
+        for group, entries in result.items():
+            for k, v in entries.items():
+                s = '%s = %s' % (k, v)
+                entry = get_export_entry(s)
+                assert entry is not None
+                entries[k] = entry
+        return result
+    except Exception:
+        stream.seek(0, 0)
+
+    def read_stream(cp, stream):
+        if hasattr(cp, 'read_file'):
+            cp.read_file(stream)
+        else:
+            cp.readfp(stream)
+
+    cp = configparser.ConfigParser()
+    try:
+        read_stream(cp, stream)
+    except configparser.MissingSectionHeaderError:
+        stream.close()
+        data = textwrap.dedent(data)
+        stream = StringIO(data)
+        read_stream(cp, stream)
+
+    result = {}
+    for key in cp.sections():
+        result[key] = entries = {}
+        for name, value in cp.items(key):
+            s = '%s = %s' % (name, value)
+            entry = get_export_entry(s)
+            assert entry is not None
+            #entry.dist = self
+            entries[name] = entry
+    return result
+
+
+def write_exports(exports, stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getwriter('utf-8')(stream)
+    cp = configparser.ConfigParser()
+    for k, v in exports.items():
+        # TODO check k, v for valid values
+        cp.add_section(k)
+        for entry in v.values():
+            if entry.suffix is None:
+                s = entry.prefix
+            else:
+                s = '%s:%s' % (entry.prefix, entry.suffix)
+            if entry.flags:
+                s = '%s [%s]' % (s, ', '.join(entry.flags))
+            cp.set(k, entry.name, s)
+    cp.write(stream)
+
+
+@contextlib.contextmanager
+def tempdir():
+    td = tempfile.mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+@contextlib.contextmanager
+def chdir(d):
+    cwd = os.getcwd()
+    try:
+        os.chdir(d)
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+@contextlib.contextmanager
+def socket_timeout(seconds=15):
+    cto = socket.getdefaulttimeout()
+    try:
+        socket.setdefaulttimeout(seconds)
+        yield
+    finally:
+        socket.setdefaulttimeout(cto)
+
+
+class cached_property(object):
+    def __init__(self, func):
+        self.func = func
+        #for attr in ('__name__', '__module__', '__doc__'):
+        #    setattr(self, attr, getattr(func, attr, None))
+
+    def __get__(self, obj, cls=None):
+        if obj is None:
+            return self
+        value = self.func(obj)
+        object.__setattr__(obj, self.func.__name__, value)
+        #obj.__dict__[self.func.__name__] = value = self.func(obj)
+        return value
+
+def convert_path(pathname):
+    """Return 'pathname' as a name that will work on the native filesystem.
+
+    The path is split on '/' and put back together again using the current
+    directory separator.  Needed because filenames in the setup script are
+    always supplied in Unix style, and have to be converted to the local
+    convention before we can actually use them in the filesystem.  Raises
+    ValueError on non-Unix-ish systems if 'pathname' either starts or
+    ends with a slash.
+    """
+    if os.sep == '/':
+        return pathname
+    if not pathname:
+        return pathname
+    if pathname[0] == '/':
+        raise ValueError("path '%s' cannot be absolute" % pathname)
+    if pathname[-1] == '/':
+        raise ValueError("path '%s' cannot end with '/'" % pathname)
+
+    paths = pathname.split('/')
+    while os.curdir in paths:
+        paths.remove(os.curdir)
+    if not paths:
+        return os.curdir
+    return os.path.join(*paths)
+
+
+class FileOperator(object):
+    def __init__(self, dry_run=False):
+        self.dry_run = dry_run
+        self.ensured = set()
+        self._init_record()
+
+    def _init_record(self):
+        self.record = False
+        self.files_written = set()
+        self.dirs_created = set()
+
+    def record_as_written(self, path):
+        if self.record:
+            self.files_written.add(path)
+
+    def newer(self, source, target):
+        """Tell if the target is newer than the source.
+
+        Returns true if 'source' exists and is more recently modified than
+        'target', or if 'source' exists and 'target' doesn't.
+
+        Returns false if both exist and 'target' is the same age or younger
+        than 'source'. Raise PackagingFileError if 'source' does not exist.
+
+        Note that this test is not very accurate: files created in the same
+        second will have the same "age".
+        """
+        if not os.path.exists(source):
+            raise DistlibException("file '%r' does not exist" %
+                                   os.path.abspath(source))
+        if not os.path.exists(target):
+            return True
+
+        return os.stat(source).st_mtime > os.stat(target).st_mtime
+
+    def copy_file(self, infile, outfile, check=True):
+        """Copy a file respecting dry-run and force flags.
+        """
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying %s to %s', infile, outfile)
+        if not self.dry_run:
+            msg = None
+            if check:
+                if os.path.islink(outfile):
+                    msg = '%s is a symlink' % outfile
+                elif os.path.exists(outfile) and not os.path.isfile(outfile):
+                    msg = '%s is a non-regular file' % outfile
+            if msg:
+                raise ValueError(msg + ' which would be overwritten')
+            shutil.copyfile(infile, outfile)
+        self.record_as_written(outfile)
+
+    def copy_stream(self, instream, outfile, encoding=None):
+        assert not os.path.isdir(outfile)
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying stream %s to %s', instream, outfile)
+        if not self.dry_run:
+            if encoding is None:
+                outstream = open(outfile, 'wb')
+            else:
+                outstream = codecs.open(outfile, 'w', encoding=encoding)
+            try:
+                shutil.copyfileobj(instream, outstream)
+            finally:
+                outstream.close()
+        self.record_as_written(outfile)
+
+    def write_binary_file(self, path, data):
+        self.ensure_dir(os.path.dirname(path))
+        if not self.dry_run:
+            if os.path.exists(path):
+                os.remove(path)
+            with open(path, 'wb') as f:
+                f.write(data)
+        self.record_as_written(path)
+
+    def write_text_file(self, path, data, encoding):
+        self.write_binary_file(path, data.encode(encoding))
+
+    def set_mode(self, bits, mask, files):
+        if os.name == 'posix' or (os.name == 'java' and os._name == 'posix'):
+            # Set the executable bits (owner, group, and world) on
+            # all the files specified.
+            for f in files:
+                if self.dry_run:
+                    logger.info("changing mode of %s", f)
+                else:
+                    mode = (os.stat(f).st_mode | bits) & mask
+                    logger.info("changing mode of %s to %o", f, mode)
+                    os.chmod(f, mode)
+
+    set_executable_mode = lambda s, f: s.set_mode(0o555, 0o7777, f)
+
+    def ensure_dir(self, path):
+        path = os.path.abspath(path)
+        if path not in self.ensured and not os.path.exists(path):
+            self.ensured.add(path)
+            d, f = os.path.split(path)
+            self.ensure_dir(d)
+            logger.info('Creating %s' % path)
+            if not self.dry_run:
+                os.mkdir(path)
+            if self.record:
+                self.dirs_created.add(path)
+
+    def byte_compile(self, path, optimize=False, force=False, prefix=None, hashed_invalidation=False):
+        dpath = cache_from_source(path, not optimize)
+        logger.info('Byte-compiling %s to %s', path, dpath)
+        if not self.dry_run:
+            if force or self.newer(path, dpath):
+                if not prefix:
+                    diagpath = None
+                else:
+                    assert path.startswith(prefix)
+                    diagpath = path[len(prefix):]
+            compile_kwargs = {}
+            if hashed_invalidation and hasattr(py_compile, 'PycInvalidationMode'):
+                compile_kwargs['invalidation_mode'] = py_compile.PycInvalidationMode.CHECKED_HASH
+            py_compile.compile(path, dpath, diagpath, True, **compile_kwargs)     # raise error
+        self.record_as_written(dpath)
+        return dpath
+
+    def ensure_removed(self, path):
+        if os.path.exists(path):
+            if os.path.isdir(path) and not os.path.islink(path):
+                logger.debug('Removing directory tree at %s', path)
+                if not self.dry_run:
+                    shutil.rmtree(path)
+                if self.record:
+                    if path in self.dirs_created:
+                        self.dirs_created.remove(path)
+            else:
+                if os.path.islink(path):
+                    s = 'link'
+                else:
+                    s = 'file'
+                logger.debug('Removing %s %s', s, path)
+                if not self.dry_run:
+                    os.remove(path)
+                if self.record:
+                    if path in self.files_written:
+                        self.files_written.remove(path)
+
+    def is_writable(self, path):
+        result = False
+        while not result:
+            if os.path.exists(path):
+                result = os.access(path, os.W_OK)
+                break
+            parent = os.path.dirname(path)
+            if parent == path:
+                break
+            path = parent
+        return result
+
+    def commit(self):
+        """
+        Commit recorded changes, turn off recording, return
+        changes.
+        """
+        assert self.record
+        result = self.files_written, self.dirs_created
+        self._init_record()
+        return result
+
+    def rollback(self):
+        if not self.dry_run:
+            for f in list(self.files_written):
+                if os.path.exists(f):
+                    os.remove(f)
+            # dirs should all be empty now, except perhaps for
+            # __pycache__ subdirs
+            # reverse so that subdirs appear before their parents
+            dirs = sorted(self.dirs_created, reverse=True)
+            for d in dirs:
+                flist = os.listdir(d)
+                if flist:
+                    assert flist == ['__pycache__']
+                    sd = os.path.join(d, flist[0])
+                    os.rmdir(sd)
+                os.rmdir(d)     # should fail if non-empty
+        self._init_record()
+
+def resolve(module_name, dotted_path):
+    if module_name in sys.modules:
+        mod = sys.modules[module_name]
+    else:
+        mod = __import__(module_name)
+    if dotted_path is None:
+        result = mod
+    else:
+        parts = dotted_path.split('.')
+        result = getattr(mod, parts.pop(0))
+        for p in parts:
+            result = getattr(result, p)
+    return result
+
+
+class ExportEntry(object):
+    def __init__(self, name, prefix, suffix, flags):
+        self.name = name
+        self.prefix = prefix
+        self.suffix = suffix
+        self.flags = flags
+
+    @cached_property
+    def value(self):
+        return resolve(self.prefix, self.suffix)
+
+    def __repr__(self):  # pragma: no cover
+        return '<ExportEntry %s = %s:%s %s>' % (self.name, self.prefix,
+                                                self.suffix, self.flags)
+
+    def __eq__(self, other):
+        if not isinstance(other, ExportEntry):
+            result = False
+        else:
+            result = (self.name == other.name and
+                      self.prefix == other.prefix and
+                      self.suffix == other.suffix and
+                      self.flags == other.flags)
+        return result
+
+    __hash__ = object.__hash__
+
+
+ENTRY_RE = re.compile(r'''(?P<name>(\w|[-.+])+)
+                      \s*=\s*(?P<callable>(\w+)([:\.]\w+)*)
+                      \s*(\[\s*(?P<flags>\w+(=\w+)?(,\s*\w+(=\w+)?)*)\s*\])?
+                      ''', re.VERBOSE)
+
+def get_export_entry(specification):
+    m = ENTRY_RE.search(specification)
+    if not m:
+        result = None
+        if '[' in specification or ']' in specification:
+            raise DistlibException("Invalid specification "
+                                   "'%s'" % specification)
+    else:
+        d = m.groupdict()
+        name = d['name']
+        path = d['callable']
+        colons = path.count(':')
+        if colons == 0:
+            prefix, suffix = path, None
+        else:
+            if colons != 1:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            prefix, suffix = path.split(':')
+        flags = d['flags']
+        if flags is None:
+            if '[' in specification or ']' in specification:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            flags = []
+        else:
+            flags = [f.strip() for f in flags.split(',')]
+        result = ExportEntry(name, prefix, suffix, flags)
+    return result
+
+
+def get_cache_base(suffix=None):
+    """
+    Return the default base location for distlib caches. If the directory does
+    not exist, it is created. Use the suffix provided for the base directory,
+    and default to '.distlib' if it isn't provided.
+
+    On Windows, if LOCALAPPDATA is defined in the environment, then it is
+    assumed to be a directory, and will be the parent directory of the result.
+    On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
+    directory - using os.expanduser('~') - will be the parent directory of
+    the result.
+
+    The result is just the directory '.distlib' in the parent directory as
+    determined above, or with the name specified with ``suffix``.
+    """
+    if suffix is None:
+        suffix = '.distlib'
+    if os.name == 'nt' and 'LOCALAPPDATA' in os.environ:
+        result = os.path.expandvars('$localappdata')
+    else:
+        # Assume posix, or old Windows
+        result = os.path.expanduser('~')
+    # we use 'isdir' instead of 'exists', because we want to
+    # fail if there's a file with that name
+    if os.path.isdir(result):
+        usable = os.access(result, os.W_OK)
+        if not usable:
+            logger.warning('Directory exists but is not writable: %s', result)
+    else:
+        try:
+            os.makedirs(result)
+            usable = True
+        except OSError:
+            logger.warning('Unable to create %s', result, exc_info=True)
+            usable = False
+    if not usable:
+        result = tempfile.mkdtemp()
+        logger.warning('Default location unusable, using %s', result)
+    return os.path.join(result, suffix)
+
+
+def path_to_cache_dir(path):
+    """
+    Convert an absolute path to a directory name for use in a cache.
+
+    The algorithm used is:
+
+    #. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
+    #. Any occurrence of ``os.sep`` is replaced with ``'--'``.
+    #. ``'.cache'`` is appended.
+    """
+    d, p = os.path.splitdrive(os.path.abspath(path))
+    if d:
+        d = d.replace(':', '---')
+    p = p.replace(os.sep, '--')
+    return d + p + '.cache'
+
+
+def ensure_slash(s):
+    if not s.endswith('/'):
+        return s + '/'
+    return s
+
+
+def parse_credentials(netloc):
+    username = password = None
+    if '@' in netloc:
+        prefix, netloc = netloc.rsplit('@', 1)
+        if ':' not in prefix:
+            username = prefix
+        else:
+            username, password = prefix.split(':', 1)
+    if username:
+        username = unquote(username)
+    if password:
+        password = unquote(password)
+    return username, password, netloc
+
+
+def get_process_umask():
+    result = os.umask(0o22)
+    os.umask(result)
+    return result
+
+def is_string_sequence(seq):
+    result = True
+    i = None
+    for i, s in enumerate(seq):
+        if not isinstance(s, string_types):
+            result = False
+            break
+    assert i is not None
+    return result
+
+PROJECT_NAME_AND_VERSION = re.compile('([a-z0-9_]+([.-][a-z_][a-z0-9_]*)*)-'
+                                      '([a-z0-9_.+-]+)', re.I)
+PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')
+
+
+def split_filename(filename, project_name=None):
+    """
+    Extract name, version, python version from a filename (no extension)
+
+    Return name, version, pyver or None
+    """
+    result = None
+    pyver = None
+    filename = unquote(filename).replace(' ', '-')
+    m = PYTHON_VERSION.search(filename)
+    if m:
+        pyver = m.group(1)
+        filename = filename[:m.start()]
+    if project_name and len(filename) > len(project_name) + 1:
+        m = re.match(re.escape(project_name) + r'\b', filename)
+        if m:
+            n = m.end()
+            result = filename[:n], filename[n + 1:], pyver
+    if result is None:
+        m = PROJECT_NAME_AND_VERSION.match(filename)
+        if m:
+            result = m.group(1), m.group(3), pyver
+    return result
+
+# Allow spaces in name because of legacy dists like "Twisted Core"
+NAME_VERSION_RE = re.compile(r'(?P<name>[\w .-]+)\s*'
+                             r'\(\s*(?P<ver>[^\s)]+)\)$')
+
+def parse_name_and_version(p):
+    """
+    A utility method used to get name and version from a string.
+
+    From e.g. a Provides-Dist value.
+
+    :param p: A value in a form 'foo (1.0)'
+    :return: The name and version as a tuple.
+    """
+    m = NAME_VERSION_RE.match(p)
+    if not m:
+        raise DistlibException('Ill-formed name/version string: \'%s\'' % p)
+    d = m.groupdict()
+    return d['name'].strip().lower(), d['ver']
+
+def get_extras(requested, available):
+    result = set()
+    requested = set(requested or [])
+    available = set(available or [])
+    if '*' in requested:
+        requested.remove('*')
+        result |= available
+    for r in requested:
+        if r == '-':
+            result.add(r)
+        elif r.startswith('-'):
+            unwanted = r[1:]
+            if unwanted not in available:
+                logger.warning('undeclared extra: %s' % unwanted)
+            if unwanted in result:
+                result.remove(unwanted)
+        else:
+            if r not in available:
+                logger.warning('undeclared extra: %s' % r)
+            result.add(r)
+    return result
+#
+# Extended metadata functionality
+#
+
+def _get_external_data(url):
+    result = {}
+    try:
+        # urlopen might fail if it runs into redirections,
+        # because of Python issue #13696. Fixed in locators
+        # using a custom redirect handler.
+        resp = urlopen(url)
+        headers = resp.info()
+        ct = headers.get('Content-Type')
+        if not ct.startswith('application/json'):
+            logger.debug('Unexpected response for JSON request: %s', ct)
+        else:
+            reader = codecs.getreader('utf-8')(resp)
+            #data = reader.read().decode('utf-8')
+            #result = json.loads(data)
+            result = json.load(reader)
+    except Exception as e:
+        logger.exception('Failed to get external data for %s: %s', url, e)
+    return result
+
+_external_data_base_url = 'https://www.red-dove.com/pypi/projects/'
+
+def get_project_data(name):
+    url = '%s/%s/project.json' % (name[0].upper(), name)
+    url = urljoin(_external_data_base_url, url)
+    result = _get_external_data(url)
+    return result
+
+def get_package_data(name, version):
+    url = '%s/%s/package-%s.json' % (name[0].upper(), name, version)
+    url = urljoin(_external_data_base_url, url)
+    return _get_external_data(url)
+
+
+class Cache(object):
+    """
+    A class implementing a cache for resources that need to live in the file system
+    e.g. shared libraries. This class was moved from resources to here because it
+    could be used by other modules, e.g. the wheel module.
+    """
+
+    def __init__(self, base):
+        """
+        Initialise an instance.
+
+        :param base: The base directory where the cache should be located.
+        """
+        # we use 'isdir' instead of 'exists', because we want to
+        # fail if there's a file with that name
+        if not os.path.isdir(base):  # pragma: no cover
+            os.makedirs(base)
+        if (os.stat(base).st_mode & 0o77) != 0:
+            logger.warning('Directory \'%s\' is not private', base)
+        self.base = os.path.abspath(os.path.normpath(base))
+
+    def prefix_to_dir(self, prefix):
+        """
+        Converts a resource prefix to a directory name in the cache.
+        """
+        return path_to_cache_dir(prefix)
+
+    def clear(self):
+        """
+        Clear the cache.
+        """
+        not_removed = []
+        for fn in os.listdir(self.base):
+            fn = os.path.join(self.base, fn)
+            try:
+                if os.path.islink(fn) or os.path.isfile(fn):
+                    os.remove(fn)
+                elif os.path.isdir(fn):
+                    shutil.rmtree(fn)
+            except Exception:
+                not_removed.append(fn)
+        return not_removed
+
+
+class EventMixin(object):
+    """
+    A very simple publish/subscribe system.
+    """
+    def __init__(self):
+        self._subscribers = {}
+
+    def add(self, event, subscriber, append=True):
+        """
+        Add a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be added (and called when the
+                           event is published).
+        :param append: Whether to append or prepend the subscriber to an
+                       existing subscriber list for the event.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            subs[event] = deque([subscriber])
+        else:
+            sq = subs[event]
+            if append:
+                sq.append(subscriber)
+            else:
+                sq.appendleft(subscriber)
+
+    def remove(self, event, subscriber):
+        """
+        Remove a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be removed.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            raise ValueError('No subscribers: %r' % event)
+        subs[event].remove(subscriber)
+
+    def get_subscribers(self, event):
+        """
+        Return an iterator for the subscribers for an event.
+        :param event: The event to return subscribers for.
+        """
+        return iter(self._subscribers.get(event, ()))
+
+    def publish(self, event, *args, **kwargs):
+        """
+        Publish a event and return a list of values returned by its
+        subscribers.
+
+        :param event: The event to publish.
+        :param args: The positional arguments to pass to the event's
+                     subscribers.
+        :param kwargs: The keyword arguments to pass to the event's
+                       subscribers.
+        """
+        result = []
+        for subscriber in self.get_subscribers(event):
+            try:
+                value = subscriber(event, *args, **kwargs)
+            except Exception:
+                logger.exception('Exception during event publication')
+                value = None
+            result.append(value)
+        logger.debug('publish %s: args = %s, kwargs = %s, result = %s',
+                     event, args, kwargs, result)
+        return result
+
+#
+# Simple sequencing
+#
+class Sequencer(object):
+    def __init__(self):
+        self._preds = {}
+        self._succs = {}
+        self._nodes = set()     # nodes with no preds/succs
+
+    def add_node(self, node):
+        self._nodes.add(node)
+
+    def remove_node(self, node, edges=False):
+        if node in self._nodes:
+            self._nodes.remove(node)
+        if edges:
+            for p in set(self._preds.get(node, ())):
+                self.remove(p, node)
+            for s in set(self._succs.get(node, ())):
+                self.remove(node, s)
+            # Remove empties
+            for k, v in list(self._preds.items()):
+                if not v:
+                    del self._preds[k]
+            for k, v in list(self._succs.items()):
+                if not v:
+                    del self._succs[k]
+
+    def add(self, pred, succ):
+        assert pred != succ
+        self._preds.setdefault(succ, set()).add(pred)
+        self._succs.setdefault(pred, set()).add(succ)
+
+    def remove(self, pred, succ):
+        assert pred != succ
+        try:
+            preds = self._preds[succ]
+            succs = self._succs[pred]
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of anything' % succ)
+        try:
+            preds.remove(pred)
+            succs.remove(succ)
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of %r' % (succ, pred))
+
+    def is_step(self, step):
+        return (step in self._preds or step in self._succs or
+                step in self._nodes)
+
+    def get_steps(self, final):
+        if not self.is_step(final):
+            raise ValueError('Unknown: %r' % final)
+        result = []
+        todo = []
+        seen = set()
+        todo.append(final)
+        while todo:
+            step = todo.pop(0)
+            if step in seen:
+                # if a step was already seen,
+                # move it to the end (so it will appear earlier
+                # when reversed on return) ... but not for the
+                # final step, as that would be confusing for
+                # users
+                if step != final:
+                    result.remove(step)
+                    result.append(step)
+            else:
+                seen.add(step)
+                result.append(step)
+                preds = self._preds.get(step, ())
+                todo.extend(preds)
+        return reversed(result)
+
+    @property
+    def strong_connections(self):
+        #http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+        index_counter = [0]
+        stack = []
+        lowlinks = {}
+        index = {}
+        result = []
+
+        graph = self._succs
+
+        def strongconnect(node):
+            # set the depth index for this node to the smallest unused index
+            index[node] = index_counter[0]
+            lowlinks[node] = index_counter[0]
+            index_counter[0] += 1
+            stack.append(node)
+
+            # Consider successors
+            try:
+                successors = graph[node]
+            except Exception:
+                successors = []
+            for successor in successors:
+                if successor not in lowlinks:
+                    # Successor has not yet been visited
+                    strongconnect(successor)
+                    lowlinks[node] = min(lowlinks[node],lowlinks[successor])
+                elif successor in stack:
+                    # the successor is in the stack and hence in the current
+                    # strongly connected component (SCC)
+                    lowlinks[node] = min(lowlinks[node],index[successor])
+
+            # If `node` is a root node, pop the stack and generate an SCC
+            if lowlinks[node] == index[node]:
+                connected_component = []
+
+                while True:
+                    successor = stack.pop()
+                    connected_component.append(successor)
+                    if successor == node: break
+                component = tuple(connected_component)
+                # storing the result
+                result.append(component)
+
+        for node in graph:
+            if node not in lowlinks:
+                strongconnect(node)
+
+        return result
+
+    @property
+    def dot(self):
+        result = ['digraph G {']
+        for succ in self._preds:
+            preds = self._preds[succ]
+            for pred in preds:
+                result.append('  %s -> %s;' % (pred, succ))
+        for node in self._nodes:
+            result.append('  %s;' % node)
+        result.append('}')
+        return '\n'.join(result)
+
+#
+# Unarchiving functionality for zip, tar, tgz, tbz, whl
+#
+
+ARCHIVE_EXTENSIONS = ('.tar.gz', '.tar.bz2', '.tar', '.zip',
+                      '.tgz', '.tbz', '.whl')
+
+def unarchive(archive_filename, dest_dir, format=None, check=True):
+
+    def check_path(path):
+        if not isinstance(path, text_type):
+            path = path.decode('utf-8')
+        p = os.path.abspath(os.path.join(dest_dir, path))
+        if not p.startswith(dest_dir) or p[plen] != os.sep:
+            raise ValueError('path outside destination: %r' % p)
+
+    dest_dir = os.path.abspath(dest_dir)
+    plen = len(dest_dir)
+    archive = None
+    if format is None:
+        if archive_filename.endswith(('.zip', '.whl')):
+            format = 'zip'
+        elif archive_filename.endswith(('.tar.gz', '.tgz')):
+            format = 'tgz'
+            mode = 'r:gz'
+        elif archive_filename.endswith(('.tar.bz2', '.tbz')):
+            format = 'tbz'
+            mode = 'r:bz2'
+        elif archive_filename.endswith('.tar'):
+            format = 'tar'
+            mode = 'r'
+        else:  # pragma: no cover
+            raise ValueError('Unknown format for %r' % archive_filename)
+    try:
+        if format == 'zip':
+            archive = ZipFile(archive_filename, 'r')
+            if check:
+                names = archive.namelist()
+                for name in names:
+                    check_path(name)
+        else:
+            archive = tarfile.open(archive_filename, mode)
+            if check:
+                names = archive.getnames()
+                for name in names:
+                    check_path(name)
+        if format != 'zip' and sys.version_info[0] < 3:
+            # See Python issue 17153. If the dest path contains Unicode,
+            # tarfile extraction fails on Python 2.x if a member path name
+            # contains non-ASCII characters - it leads to an implicit
+            # bytes -> unicode conversion using ASCII to decode.
+            for tarinfo in archive.getmembers():
+                if not isinstance(tarinfo.name, text_type):
+                    tarinfo.name = tarinfo.name.decode('utf-8')
+        archive.extractall(dest_dir)
+
+    finally:
+        if archive:
+            archive.close()
+
+
+def zip_dir(directory):
+    """zip a directory tree into a BytesIO object"""
+    result = io.BytesIO()
+    dlen = len(directory)
+    with ZipFile(result, "w") as zf:
+        for root, dirs, files in os.walk(directory):
+            for name in files:
+                full = os.path.join(root, name)
+                rel = root[dlen:]
+                dest = os.path.join(rel, name)
+                zf.write(full, dest)
+    return result
+
+#
+# Simple progress bar
+#
+
+UNITS = ('', 'K', 'M', 'G','T','P')
+
+
+class Progress(object):
+    unknown = 'UNKNOWN'
+
+    def __init__(self, minval=0, maxval=100):
+        assert maxval is None or maxval >= minval
+        self.min = self.cur = minval
+        self.max = maxval
+        self.started = None
+        self.elapsed = 0
+        self.done = False
+
+    def update(self, curval):
+        assert self.min <= curval
+        assert self.max is None or curval <= self.max
+        self.cur = curval
+        now = time.time()
+        if self.started is None:
+            self.started = now
+        else:
+            self.elapsed = now - self.started
+
+    def increment(self, incr):
+        assert incr >= 0
+        self.update(self.cur + incr)
+
+    def start(self):
+        self.update(self.min)
+        return self
+
+    def stop(self):
+        if self.max is not None:
+            self.update(self.max)
+        self.done = True
+
+    @property
+    def maximum(self):
+        return self.unknown if self.max is None else self.max
+
+    @property
+    def percentage(self):
+        if self.done:
+            result = '100 %'
+        elif self.max is None:
+            result = ' ?? %'
+        else:
+            v = 100.0 * (self.cur - self.min) / (self.max - self.min)
+            result = '%3d %%' % v
+        return result
+
+    def format_duration(self, duration):
+        if (duration <= 0) and self.max is None or self.cur == self.min:
+            result = '??:??:??'
+        #elif duration < 1:
+        #    result = '--:--:--'
+        else:
+            result = time.strftime('%H:%M:%S', time.gmtime(duration))
+        return result
+
+    @property
+    def ETA(self):
+        if self.done:
+            prefix = 'Done'
+            t = self.elapsed
+            #import pdb; pdb.set_trace()
+        else:
+            prefix = 'ETA '
+            if self.max is None:
+                t = -1
+            elif self.elapsed == 0 or (self.cur == self.min):
+                t = 0
+            else:
+                #import pdb; pdb.set_trace()
+                t = float(self.max - self.min)
+                t /= self.cur - self.min
+                t = (t - 1) * self.elapsed
+        return '%s: %s' % (prefix, self.format_duration(t))
+
+    @property
+    def speed(self):
+        if self.elapsed == 0:
+            result = 0.0
+        else:
+            result = (self.cur - self.min) / self.elapsed
+        for unit in UNITS:
+            if result < 1000:
+                break
+            result /= 1000.0
+        return '%d %sB/s' % (result, unit)
+
+#
+# Glob functionality
+#
+
+RICH_GLOB = re.compile(r'\{([^}]*)\}')
+_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')
+_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')
+
+
+def iglob(path_glob):
+    """Extended globbing function that supports ** and {opt1,opt2,opt3}."""
+    if _CHECK_RECURSIVE_GLOB.search(path_glob):
+        msg = """invalid glob %r: recursive glob "**" must be used alone"""
+        raise ValueError(msg % path_glob)
+    if _CHECK_MISMATCH_SET.search(path_glob):
+        msg = """invalid glob %r: mismatching set marker '{' or '}'"""
+        raise ValueError(msg % path_glob)
+    return _iglob(path_glob)
+
+
+def _iglob(path_glob):
+    rich_path_glob = RICH_GLOB.split(path_glob, 1)
+    if len(rich_path_glob) > 1:
+        assert len(rich_path_glob) == 3, rich_path_glob
+        prefix, set, suffix = rich_path_glob
+        for item in set.split(','):
+            for path in _iglob(''.join((prefix, item, suffix))):
+                yield path
+    else:
+        if '**' not in path_glob:
+            for item in std_iglob(path_glob):
+                yield item
+        else:
+            prefix, radical = path_glob.split('**', 1)
+            if prefix == '':
+                prefix = '.'
+            if radical == '':
+                radical = '*'
+            else:
+                # we support both
+                radical = radical.lstrip('/')
+                radical = radical.lstrip('\\')
+            for path, dir, files in os.walk(prefix):
+                path = os.path.normpath(path)
+                for fn in _iglob(os.path.join(path, radical)):
+                    yield fn
+
+if ssl:
+    from .compat import (HTTPSHandler as BaseHTTPSHandler, match_hostname,
+                         CertificateError)
+
+
+#
+# HTTPSConnection which verifies certificates/matches domains
+#
+
+    class HTTPSConnection(httplib.HTTPSConnection):
+        ca_certs = None # set this to the path to the certs file (.pem)
+        check_domain = True # only used if ca_certs is not None
+
+        # noinspection PyPropertyAccess
+        def connect(self):
+            sock = socket.create_connection((self.host, self.port), self.timeout)
+            if getattr(self, '_tunnel_host', False):
+                self.sock = sock
+                self._tunnel()
+
+            if not hasattr(ssl, 'SSLContext'):
+                # For 2.x
+                if self.ca_certs:
+                    cert_reqs = ssl.CERT_REQUIRED
+                else:
+                    cert_reqs = ssl.CERT_NONE
+                self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
+                                            cert_reqs=cert_reqs,
+                                            ssl_version=ssl.PROTOCOL_SSLv23,
+                                            ca_certs=self.ca_certs)
+            else:  # pragma: no cover
+                context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+                context.options |= ssl.OP_NO_SSLv2
+                if self.cert_file:
+                    context.load_cert_chain(self.cert_file, self.key_file)
+                kwargs = {}
+                if self.ca_certs:
+                    context.verify_mode = ssl.CERT_REQUIRED
+                    context.load_verify_locations(cafile=self.ca_certs)
+                    if getattr(ssl, 'HAS_SNI', False):
+                        kwargs['server_hostname'] = self.host
+                self.sock = context.wrap_socket(sock, **kwargs)
+            if self.ca_certs and self.check_domain:
+                try:
+                    match_hostname(self.sock.getpeercert(), self.host)
+                    logger.debug('Host verified: %s', self.host)
+                except CertificateError:  # pragma: no cover
+                    self.sock.shutdown(socket.SHUT_RDWR)
+                    self.sock.close()
+                    raise
+
+    class HTTPSHandler(BaseHTTPSHandler):
+        def __init__(self, ca_certs, check_domain=True):
+            BaseHTTPSHandler.__init__(self)
+            self.ca_certs = ca_certs
+            self.check_domain = check_domain
+
+        def _conn_maker(self, *args, **kwargs):
+            """
+            This is called to create a connection instance. Normally you'd
+            pass a connection class to do_open, but it doesn't actually check for
+            a class, and just expects a callable. As long as we behave just as a
+            constructor would have, we should be OK. If it ever changes so that
+            we *must* pass a class, we'll create an UnsafeHTTPSConnection class
+            which just sets check_domain to False in the class definition, and
+            choose which one to pass to do_open.
+            """
+            result = HTTPSConnection(*args, **kwargs)
+            if self.ca_certs:
+                result.ca_certs = self.ca_certs
+                result.check_domain = self.check_domain
+            return result
+
+        def https_open(self, req):
+            try:
+                return self.do_open(self._conn_maker, req)
+            except URLError as e:
+                if 'certificate verify failed' in str(e.reason):
+                    raise CertificateError('Unable to verify server certificate '
+                                           'for %s' % req.host)
+                else:
+                    raise
+
+    #
+    # To prevent against mixing HTTP traffic with HTTPS (examples: A Man-In-The-
+    # Middle proxy using HTTP listens on port 443, or an index mistakenly serves
+    # HTML containing a http://xyz link when it should be https://xyz),
+    # you can use the following handler class, which does not allow HTTP traffic.
+    #
+    # It works by inheriting from HTTPHandler - so build_opener won't add a
+    # handler for HTTP itself.
+    #
+    class HTTPSOnlyHandler(HTTPSHandler, HTTPHandler):
+        def http_open(self, req):
+            raise URLError('Unexpected HTTP request on what should be a secure '
+                           'connection: %s' % req)
+
+#
+# XML-RPC with timeouts
+#
+
+_ver_info = sys.version_info[:2]
+
+if _ver_info == (2, 6):
+    class HTTP(httplib.HTTP):
+        def __init__(self, host='', port=None, **kwargs):
+            if port == 0:   # 0 means use port 0, not the default port
+                port = None
+            self._setup(self._connection_class(host, port, **kwargs))
+
+
+    if ssl:
+        class HTTPS(httplib.HTTPS):
+            def __init__(self, host='', port=None, **kwargs):
+                if port == 0:   # 0 means use port 0, not the default port
+                    port = None
+                self._setup(self._connection_class(host, port, **kwargs))
+
+
+class Transport(xmlrpclib.Transport):
+    def __init__(self, timeout, use_datetime=0):
+        self.timeout = timeout
+        xmlrpclib.Transport.__init__(self, use_datetime)
+
+    def make_connection(self, host):
+        h, eh, x509 = self.get_host_info(host)
+        if _ver_info == (2, 6):
+            result = HTTP(h, timeout=self.timeout)
+        else:
+            if not self._connection or host != self._connection[0]:
+                self._extra_headers = eh
+                self._connection = host, httplib.HTTPConnection(h)
+            result = self._connection[1]
+        return result
+
+if ssl:
+    class SafeTransport(xmlrpclib.SafeTransport):
+        def __init__(self, timeout, use_datetime=0):
+            self.timeout = timeout
+            xmlrpclib.SafeTransport.__init__(self, use_datetime)
+
+        def make_connection(self, host):
+            h, eh, kwargs = self.get_host_info(host)
+            if not kwargs:
+                kwargs = {}
+            kwargs['timeout'] = self.timeout
+            if _ver_info == (2, 6):
+                result = HTTPS(host, None, **kwargs)
+            else:
+                if not self._connection or host != self._connection[0]:
+                    self._extra_headers = eh
+                    self._connection = host, httplib.HTTPSConnection(h, None,
+                                                                     **kwargs)
+                result = self._connection[1]
+            return result
+
+
+class ServerProxy(xmlrpclib.ServerProxy):
+    def __init__(self, uri, **kwargs):
+        self.timeout = timeout = kwargs.pop('timeout', None)
+        # The above classes only come into play if a timeout
+        # is specified
+        if timeout is not None:
+            scheme, _ = splittype(uri)
+            use_datetime = kwargs.get('use_datetime', 0)
+            if scheme == 'https':
+                tcls = SafeTransport
+            else:
+                tcls = Transport
+            kwargs['transport'] = t = tcls(timeout, use_datetime=use_datetime)
+            self.transport = t
+        xmlrpclib.ServerProxy.__init__(self, uri, **kwargs)
+
+#
+# CSV functionality. This is provided because on 2.x, the csv module can't
+# handle Unicode. However, we need to deal with Unicode in e.g. RECORD files.
+#
+
+def _csv_open(fn, mode, **kwargs):
+    if sys.version_info[0] < 3:
+        mode += 'b'
+    else:
+        kwargs['newline'] = ''
+        # Python 3 determines encoding from locale. Force 'utf-8'
+        # file encoding to match other forced utf-8 encoding
+        kwargs['encoding'] = 'utf-8'
+    return open(fn, mode, **kwargs)
+
+
+class CSVBase(object):
+    defaults = {
+        'delimiter': str(','),      # The strs are used because we need native
+        'quotechar': str('"'),      # str in the csv API (2.x won't take
+        'lineterminator': str('\n') # Unicode)
+    }
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.stream.close()
+
+
+class CSVReader(CSVBase):
+    def __init__(self, **kwargs):
+        if 'stream' in kwargs:
+            stream = kwargs['stream']
+            if sys.version_info[0] >= 3:
+                # needs to be a text stream
+                stream = codecs.getreader('utf-8')(stream)
+            self.stream = stream
+        else:
+            self.stream = _csv_open(kwargs['path'], 'r')
+        self.reader = csv.reader(self.stream, **self.defaults)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        result = next(self.reader)
+        if sys.version_info[0] < 3:
+            for i, item in enumerate(result):
+                if not isinstance(item, text_type):
+                    result[i] = item.decode('utf-8')
+        return result
+
+    __next__ = next
+
+class CSVWriter(CSVBase):
+    def __init__(self, fn, **kwargs):
+        self.stream = _csv_open(fn, 'w')
+        self.writer = csv.writer(self.stream, **self.defaults)
+
+    def writerow(self, row):
+        if sys.version_info[0] < 3:
+            r = []
+            for item in row:
+                if isinstance(item, text_type):
+                    item = item.encode('utf-8')
+                r.append(item)
+            row = r
+        self.writer.writerow(row)
+
+#
+#   Configurator functionality
+#
+
+class Configurator(BaseConfigurator):
+
+    value_converters = dict(BaseConfigurator.value_converters)
+    value_converters['inc'] = 'inc_convert'
+
+    def __init__(self, config, base=None):
+        super(Configurator, self).__init__(config)
+        self.base = base or os.getcwd()
+
+    def configure_custom(self, config):
+        def convert(o):
+            if isinstance(o, (list, tuple)):
+                result = type(o)([convert(i) for i in o])
+            elif isinstance(o, dict):
+                if '()' in o:
+                    result = self.configure_custom(o)
+                else:
+                    result = {}
+                    for k in o:
+                        result[k] = convert(o[k])
+            else:
+                result = self.convert(o)
+            return result
+
+        c = config.pop('()')
+        if not callable(c):
+            c = self.resolve(c)
+        props = config.pop('.', None)
+        # Check for valid identifiers
+        args = config.pop('[]', ())
+        if args:
+            args = tuple([convert(o) for o in args])
+        items = [(k, convert(config[k])) for k in config if valid_ident(k)]
+        kwargs = dict(items)
+        result = c(*args, **kwargs)
+        if props:
+            for n, v in props.items():
+                setattr(result, n, convert(v))
+        return result
+
+    def __getitem__(self, key):
+        result = self.config[key]
+        if isinstance(result, dict) and '()' in result:
+            self.config[key] = result = self.configure_custom(result)
+        return result
+
+    def inc_convert(self, value):
+        """Default converter for the inc:// protocol."""
+        if not os.path.isabs(value):
+            value = os.path.join(self.base, value)
+        with codecs.open(value, 'r', encoding='utf-8') as f:
+            result = json.load(f)
+        return result
+
+
+class SubprocessMixin(object):
+    """
+    Mixin for running subprocesses and capturing their output
+    """
+    def __init__(self, verbose=False, progress=None):
+        self.verbose = verbose
+        self.progress = progress
+
+    def reader(self, stream, context):
+        """
+        Read lines from a subprocess' output stream and either pass to a progress
+        callable (if specified) or write progress information to sys.stderr.
+        """
+        progress = self.progress
+        verbose = self.verbose
+        while True:
+            s = stream.readline()
+            if not s:
+                break
+            if progress is not None:
+                progress(s, context)
+            else:
+                if not verbose:
+                    sys.stderr.write('.')
+                else:
+                    sys.stderr.write(s.decode('utf-8'))
+                sys.stderr.flush()
+        stream.close()
+
+    def run_command(self, cmd, **kwargs):
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, **kwargs)
+        t1 = threading.Thread(target=self.reader, args=(p.stdout, 'stdout'))
+        t1.start()
+        t2 = threading.Thread(target=self.reader, args=(p.stderr, 'stderr'))
+        t2.start()
+        p.wait()
+        t1.join()
+        t2.join()
+        if self.progress is not None:
+            self.progress('done.', 'main')
+        elif self.verbose:
+            sys.stderr.write('done.\n')
+        return p
+
+
+def normalize_name(name):
+    """Normalize a python package name a la PEP 503"""
+    # https://www.python.org/dev/peps/pep-0503/#normalized-names
+    return re.sub('[-_.]+', '-', name).lower()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..3eebe18ee849dcafe39246ce2f4cabbe8e5a2b33
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/version.py
@@ -0,0 +1,736 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2017 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Implementation of a flexible versioning scheme providing support for PEP-440,
+setuptools-compatible and semantic versioning.
+"""
+
+import logging
+import re
+
+from .compat import string_types
+from .util import parse_requirement
+
+__all__ = ['NormalizedVersion', 'NormalizedMatcher',
+           'LegacyVersion', 'LegacyMatcher',
+           'SemanticVersion', 'SemanticMatcher',
+           'UnsupportedVersionError', 'get_scheme']
+
+logger = logging.getLogger(__name__)
+
+
+class UnsupportedVersionError(ValueError):
+    """This is an unsupported version."""
+    pass
+
+
+class Version(object):
+    def __init__(self, s):
+        self._string = s = s.strip()
+        self._parts = parts = self.parse(s)
+        assert isinstance(parts, tuple)
+        assert len(parts) > 0
+
+    def parse(self, s):
+        raise NotImplementedError('please implement in a subclass')
+
+    def _check_compatible(self, other):
+        if type(self) != type(other):
+            raise TypeError('cannot compare %r and %r' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        self._check_compatible(other)
+        return self._parts < other._parts
+
+    def __gt__(self, other):
+        return not (self.__lt__(other) or self.__eq__(other))
+
+    def __le__(self, other):
+        return self.__lt__(other) or self.__eq__(other)
+
+    def __ge__(self, other):
+        return self.__gt__(other) or self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self._parts)
+
+    def __repr__(self):
+        return "%s('%s')" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+    @property
+    def is_prerelease(self):
+        raise NotImplementedError('Please implement in subclasses.')
+
+
+class Matcher(object):
+    version_class = None
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '<': lambda v, c, p: v < c,
+        '>': lambda v, c, p: v > c,
+        '<=': lambda v, c, p: v == c or v < c,
+        '>=': lambda v, c, p: v == c or v > c,
+        '==': lambda v, c, p: v == c,
+        '===': lambda v, c, p: v == c,
+        # by default, compatible => >=.
+        '~=': lambda v, c, p: v == c or v > c,
+        '!=': lambda v, c, p: v != c,
+    }
+
+    # this is a method only to support alternative implementations
+    # via overriding
+    def parse_requirement(self, s):
+        return parse_requirement(s)
+
+    def __init__(self, s):
+        if self.version_class is None:
+            raise ValueError('Please specify a version class')
+        self._string = s = s.strip()
+        r = self.parse_requirement(s)
+        if not r:
+            raise ValueError('Not valid: %r' % s)
+        self.name = r.name
+        self.key = self.name.lower()    # for case-insensitive comparisons
+        clist = []
+        if r.constraints:
+            # import pdb; pdb.set_trace()
+            for op, s in r.constraints:
+                if s.endswith('.*'):
+                    if op not in ('==', '!='):
+                        raise ValueError('\'.*\' not allowed for '
+                                         '%r constraints' % op)
+                    # Could be a partial version (e.g. for '2.*') which
+                    # won't parse as a version, so keep it as a string
+                    vn, prefix = s[:-2], True
+                    # Just to check that vn is a valid version
+                    self.version_class(vn)
+                else:
+                    # Should parse as a version, so we can create an
+                    # instance for the comparison
+                    vn, prefix = self.version_class(s), False
+                clist.append((op, vn, prefix))
+        self._parts = tuple(clist)
+
+    def match(self, version):
+        """
+        Check if the provided version matches the constraints.
+
+        :param version: The version to match against this instance.
+        :type version: String or :class:`Version` instance.
+        """
+        if isinstance(version, string_types):
+            version = self.version_class(version)
+        for operator, constraint, prefix in self._parts:
+            f = self._operators.get(operator)
+            if isinstance(f, string_types):
+                f = getattr(self, f)
+            if not f:
+                msg = ('%r not implemented '
+                       'for %s' % (operator, self.__class__.__name__))
+                raise NotImplementedError(msg)
+            if not f(version, constraint, prefix):
+                return False
+        return True
+
+    @property
+    def exact_version(self):
+        result = None
+        if len(self._parts) == 1 and self._parts[0][0] in ('==', '==='):
+            result = self._parts[0][1]
+        return result
+
+    def _check_compatible(self, other):
+        if type(self) != type(other) or self.name != other.name:
+            raise TypeError('cannot compare %s and %s' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self.key == other.key and self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self.key) + hash(self._parts)
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+
+PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?'
+                               r'(\.(post)(\d+))?(\.(dev)(\d+))?'
+                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$')
+
+
+def _pep_440_key(s):
+    s = s.strip()
+    m = PEP440_VERSION_RE.match(s)
+    if not m:
+        raise UnsupportedVersionError('Not a valid version: %s' % s)
+    groups = m.groups()
+    nums = tuple(int(v) for v in groups[1].split('.'))
+    while len(nums) > 1 and nums[-1] == 0:
+        nums = nums[:-1]
+
+    if not groups[0]:
+        epoch = 0
+    else:
+        epoch = int(groups[0])
+    pre = groups[4:6]
+    post = groups[7:9]
+    dev = groups[10:12]
+    local = groups[13]
+    if pre == (None, None):
+        pre = ()
+    else:
+        pre = pre[0], int(pre[1])
+    if post == (None, None):
+        post = ()
+    else:
+        post = post[0], int(post[1])
+    if dev == (None, None):
+        dev = ()
+    else:
+        dev = dev[0], int(dev[1])
+    if local is None:
+        local = ()
+    else:
+        parts = []
+        for part in local.split('.'):
+            # to ensure that numeric compares as > lexicographic, avoid
+            # comparing them directly, but encode a tuple which ensures
+            # correct sorting
+            if part.isdigit():
+                part = (1, int(part))
+            else:
+                part = (0, part)
+            parts.append(part)
+        local = tuple(parts)
+    if not pre:
+        # either before pre-release, or final release and after
+        if not post and dev:
+            # before pre-release
+            pre = ('a', -1)     # to sort before a0
+        else:
+            pre = ('z',)        # to sort after all pre-releases
+    # now look at the state of post and dev.
+    if not post:
+        post = ('_',)   # sort before 'a'
+    if not dev:
+        dev = ('final',)
+
+    #print('%s -> %s' % (s, m.groups()))
+    return epoch, nums, pre, post, dev, local
+
+
+_normalized_key = _pep_440_key
+
+
+class NormalizedVersion(Version):
+    """A rational version.
+
+    Good:
+        1.2         # equivalent to "1.2.0"
+        1.2.0
+        1.2a1
+        1.2.3a2
+        1.2.3b1
+        1.2.3c1
+        1.2.3.4
+        TODO: fill this out
+
+    Bad:
+        1           # minimum two numbers
+        1.2a        # release level must have a release serial
+        1.2.3b
+    """
+    def parse(self, s):
+        result = _normalized_key(s)
+        # _normalized_key loses trailing zeroes in the release
+        # clause, since that's needed to ensure that X.Y == X.Y.0 == X.Y.0.0
+        # However, PEP 440 prefix matching needs it: for example,
+        # (~= 1.4.5.0) matches differently to (~= 1.4.5.0.0).
+        m = PEP440_VERSION_RE.match(s)      # must succeed
+        groups = m.groups()
+        self._release_clause = tuple(int(v) for v in groups[1].split('.'))
+        return result
+
+    PREREL_TAGS = set(['a', 'b', 'c', 'rc', 'dev'])
+
+    @property
+    def is_prerelease(self):
+        return any(t[0] in self.PREREL_TAGS for t in self._parts if t)
+
+
+def _match_prefix(x, y):
+    x = str(x)
+    y = str(y)
+    if x == y:
+        return True
+    if not x.startswith(y):
+        return False
+    n = len(y)
+    return x[n] == '.'
+
+
+class NormalizedMatcher(Matcher):
+    version_class = NormalizedVersion
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '~=': '_match_compatible',
+        '<': '_match_lt',
+        '>': '_match_gt',
+        '<=': '_match_le',
+        '>=': '_match_ge',
+        '==': '_match_eq',
+        '===': '_match_arbitrary',
+        '!=': '_match_ne',
+    }
+
+    def _adjust_local(self, version, constraint, prefix):
+        if prefix:
+            strip_local = '+' not in constraint and version._parts[-1]
+        else:
+            # both constraint and version are
+            # NormalizedVersion instances.
+            # If constraint does not have a local component,
+            # ensure the version doesn't, either.
+            strip_local = not constraint._parts[-1] and version._parts[-1]
+        if strip_local:
+            s = version._string.split('+', 1)[0]
+            version = self.version_class(s)
+        return version, constraint
+
+    def _match_lt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version >= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_gt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version <= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_le(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version <= constraint
+
+    def _match_ge(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version >= constraint
+
+    def _match_eq(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version == constraint)
+        else:
+            result = _match_prefix(version, constraint)
+        return result
+
+    def _match_arbitrary(self, version, constraint, prefix):
+        return str(version) == str(constraint)
+
+    def _match_ne(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version != constraint)
+        else:
+            result = not _match_prefix(version, constraint)
+        return result
+
+    def _match_compatible(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version == constraint:
+            return True
+        if version < constraint:
+            return False
+#        if not prefix:
+#            return True
+        release_clause = constraint._release_clause
+        if len(release_clause) > 1:
+            release_clause = release_clause[:-1]
+        pfx = '.'.join([str(i) for i in release_clause])
+        return _match_prefix(version, pfx)
+
+_REPLACEMENTS = (
+    (re.compile('[.+-]$'), ''),                     # remove trailing puncts
+    (re.compile(r'^[.](\d)'), r'0.\1'),             # .N -> 0.N at start
+    (re.compile('^[.-]'), ''),                      # remove leading puncts
+    (re.compile(r'^\((.*)\)$'), r'\1'),             # remove parentheses
+    (re.compile(r'^v(ersion)?\s*(\d+)'), r'\2'),    # remove leading v(ersion)
+    (re.compile(r'^r(ev)?\s*(\d+)'), r'\2'),        # remove leading v(ersion)
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\b(alfa|apha)\b'), 'alpha'),      # misspelt alpha
+    (re.compile(r'\b(pre-alpha|prealpha)\b'),
+                'pre.alpha'),                       # standardise
+    (re.compile(r'\(beta\)$'), 'beta'),             # remove parentheses
+)
+
+_SUFFIX_REPLACEMENTS = (
+    (re.compile('^[:~._+-]+'), ''),                   # remove leading puncts
+    (re.compile('[,*")([\\]]'), ''),                  # remove unwanted chars
+    (re.compile('[~:+_ -]'), '.'),                    # replace illegal chars
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\.$'), ''),                       # trailing '.'
+)
+
+_NUMERIC_PREFIX = re.compile(r'(\d+(\.\d+)*)')
+
+
+def _suggest_semantic_version(s):
+    """
+    Try to suggest a semantic form for a version for which
+    _suggest_normalized_version couldn't come up with anything.
+    """
+    result = s.strip().lower()
+    for pat, repl in _REPLACEMENTS:
+        result = pat.sub(repl, result)
+    if not result:
+        result = '0.0.0'
+
+    # Now look for numeric prefix, and separate it out from
+    # the rest.
+    #import pdb; pdb.set_trace()
+    m = _NUMERIC_PREFIX.match(result)
+    if not m:
+        prefix = '0.0.0'
+        suffix = result
+    else:
+        prefix = m.groups()[0].split('.')
+        prefix = [int(i) for i in prefix]
+        while len(prefix) < 3:
+            prefix.append(0)
+        if len(prefix) == 3:
+            suffix = result[m.end():]
+        else:
+            suffix = '.'.join([str(i) for i in prefix[3:]]) + result[m.end():]
+            prefix = prefix[:3]
+        prefix = '.'.join([str(i) for i in prefix])
+        suffix = suffix.strip()
+    if suffix:
+        #import pdb; pdb.set_trace()
+        # massage the suffix.
+        for pat, repl in _SUFFIX_REPLACEMENTS:
+            suffix = pat.sub(repl, suffix)
+
+    if not suffix:
+        result = prefix
+    else:
+        sep = '-' if 'dev' in suffix else '+'
+        result = prefix + sep + suffix
+    if not is_semver(result):
+        result = None
+    return result
+
+
+def _suggest_normalized_version(s):
+    """Suggest a normalized version close to the given version string.
+
+    If you have a version string that isn't rational (i.e. NormalizedVersion
+    doesn't like it) then you might be able to get an equivalent (or close)
+    rational version from this function.
+
+    This does a number of simple normalizations to the given string, based
+    on observation of versions currently in use on PyPI. Given a dump of
+    those version during PyCon 2009, 4287 of them:
+    - 2312 (53.93%) match NormalizedVersion without change
+      with the automatic suggestion
+    - 3474 (81.04%) match when using this suggestion method
+
+    @param s {str} An irrational version string.
+    @returns A rational version string, or None, if couldn't determine one.
+    """
+    try:
+        _normalized_key(s)
+        return s   # already rational
+    except UnsupportedVersionError:
+        pass
+
+    rs = s.lower()
+
+    # part of this could use maketrans
+    for orig, repl in (('-alpha', 'a'), ('-beta', 'b'), ('alpha', 'a'),
+                       ('beta', 'b'), ('rc', 'c'), ('-final', ''),
+                       ('-pre', 'c'),
+                       ('-release', ''), ('.release', ''), ('-stable', ''),
+                       ('+', '.'), ('_', '.'), (' ', ''), ('.final', ''),
+                       ('final', '')):
+        rs = rs.replace(orig, repl)
+
+    # if something ends with dev or pre, we add a 0
+    rs = re.sub(r"pre$", r"pre0", rs)
+    rs = re.sub(r"dev$", r"dev0", rs)
+
+    # if we have something like "b-2" or "a.2" at the end of the
+    # version, that is probably beta, alpha, etc
+    # let's remove the dash or dot
+    rs = re.sub(r"([abc]|rc)[\-\.](\d+)$", r"\1\2", rs)
+
+    # 1.0-dev-r371 -> 1.0.dev371
+    # 0.1-dev-r79 -> 0.1.dev79
+    rs = re.sub(r"[\-\.](dev)[\-\.]?r?(\d+)$", r".\1\2", rs)
+
+    # Clean: 2.0.a.3, 2.0.b1, 0.9.0~c1
+    rs = re.sub(r"[.~]?([abc])\.?", r"\1", rs)
+
+    # Clean: v0.3, v1.0
+    if rs.startswith('v'):
+        rs = rs[1:]
+
+    # Clean leading '0's on numbers.
+    #TODO: unintended side-effect on, e.g., "2003.05.09"
+    # PyPI stats: 77 (~2%) better
+    rs = re.sub(r"\b0+(\d+)(?!\d)", r"\1", rs)
+
+    # Clean a/b/c with no version. E.g. "1.0a" -> "1.0a0". Setuptools infers
+    # zero.
+    # PyPI stats: 245 (7.56%) better
+    rs = re.sub(r"(\d+[abc])$", r"\g<1>0", rs)
+
+    # the 'dev-rNNN' tag is a dev tag
+    rs = re.sub(r"\.?(dev-r|dev\.r)\.?(\d+)$", r".dev\2", rs)
+
+    # clean the - when used as a pre delimiter
+    rs = re.sub(r"-(a|b|c)(\d+)$", r"\1\2", rs)
+
+    # a terminal "dev" or "devel" can be changed into ".dev0"
+    rs = re.sub(r"[\.\-](dev|devel)$", r".dev0", rs)
+
+    # a terminal "dev" can be changed into ".dev0"
+    rs = re.sub(r"(?![\.\-])dev$", r".dev0", rs)
+
+    # a terminal "final" or "stable" can be removed
+    rs = re.sub(r"(final|stable)$", "", rs)
+
+    # The 'r' and the '-' tags are post release tags
+    #   0.4a1.r10       ->  0.4a1.post10
+    #   0.9.33-17222    ->  0.9.33.post17222
+    #   0.9.33-r17222   ->  0.9.33.post17222
+    rs = re.sub(r"\.?(r|-|-r)\.?(\d+)$", r".post\2", rs)
+
+    # Clean 'r' instead of 'dev' usage:
+    #   0.9.33+r17222   ->  0.9.33.dev17222
+    #   1.0dev123       ->  1.0.dev123
+    #   1.0.git123      ->  1.0.dev123
+    #   1.0.bzr123      ->  1.0.dev123
+    #   0.1a0dev.123    ->  0.1a0.dev123
+    # PyPI stats:  ~150 (~4%) better
+    rs = re.sub(r"\.?(dev|git|bzr)\.?(\d+)$", r".dev\2", rs)
+
+    # Clean '.pre' (normalized from '-pre' above) instead of 'c' usage:
+    #   0.2.pre1        ->  0.2c1
+    #   0.2-c1         ->  0.2c1
+    #   1.0preview123   ->  1.0c123
+    # PyPI stats: ~21 (0.62%) better
+    rs = re.sub(r"\.?(pre|preview|-c)(\d+)$", r"c\g<2>", rs)
+
+    # Tcl/Tk uses "px" for their post release markers
+    rs = re.sub(r"p(\d+)$", r".post\1", rs)
+
+    try:
+        _normalized_key(rs)
+    except UnsupportedVersionError:
+        rs = None
+    return rs
+
+#
+#   Legacy version processing (distribute-compatible)
+#
+
+_VERSION_PART = re.compile(r'([a-z]+|\d+|[\.-])', re.I)
+_VERSION_REPLACE = {
+    'pre': 'c',
+    'preview': 'c',
+    '-': 'final-',
+    'rc': 'c',
+    'dev': '@',
+    '': None,
+    '.': None,
+}
+
+
+def _legacy_key(s):
+    def get_parts(s):
+        result = []
+        for p in _VERSION_PART.split(s.lower()):
+            p = _VERSION_REPLACE.get(p, p)
+            if p:
+                if '0' <= p[:1] <= '9':
+                    p = p.zfill(8)
+                else:
+                    p = '*' + p
+                result.append(p)
+        result.append('*final')
+        return result
+
+    result = []
+    for p in get_parts(s):
+        if p.startswith('*'):
+            if p < '*final':
+                while result and result[-1] == '*final-':
+                    result.pop()
+            while result and result[-1] == '00000000':
+                result.pop()
+        result.append(p)
+    return tuple(result)
+
+
+class LegacyVersion(Version):
+    def parse(self, s):
+        return _legacy_key(s)
+
+    @property
+    def is_prerelease(self):
+        result = False
+        for x in self._parts:
+            if (isinstance(x, string_types) and x.startswith('*') and
+                x < '*final'):
+                result = True
+                break
+        return result
+
+
+class LegacyMatcher(Matcher):
+    version_class = LegacyVersion
+
+    _operators = dict(Matcher._operators)
+    _operators['~='] = '_match_compatible'
+
+    numeric_re = re.compile(r'^(\d+(\.\d+)*)')
+
+    def _match_compatible(self, version, constraint, prefix):
+        if version < constraint:
+            return False
+        m = self.numeric_re.match(str(constraint))
+        if not m:
+            logger.warning('Cannot compute compatible match for version %s '
+                           ' and constraint %s', version, constraint)
+            return True
+        s = m.groups()[0]
+        if '.' in s:
+            s = s.rsplit('.', 1)[0]
+        return _match_prefix(version, s)
+
+#
+#   Semantic versioning
+#
+
+_SEMVER_RE = re.compile(r'^(\d+)\.(\d+)\.(\d+)'
+                        r'(-[a-z0-9]+(\.[a-z0-9-]+)*)?'
+                        r'(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$', re.I)
+
+
+def is_semver(s):
+    return _SEMVER_RE.match(s)
+
+
+def _semantic_key(s):
+    def make_tuple(s, absent):
+        if s is None:
+            result = (absent,)
+        else:
+            parts = s[1:].split('.')
+            # We can't compare ints and strings on Python 3, so fudge it
+            # by zero-filling numeric values so simulate a numeric comparison
+            result = tuple([p.zfill(8) if p.isdigit() else p for p in parts])
+        return result
+
+    m = is_semver(s)
+    if not m:
+        raise UnsupportedVersionError(s)
+    groups = m.groups()
+    major, minor, patch = [int(i) for i in groups[:3]]
+    # choose the '|' and '*' so that versions sort correctly
+    pre, build = make_tuple(groups[3], '|'), make_tuple(groups[5], '*')
+    return (major, minor, patch), pre, build
+
+
+class SemanticVersion(Version):
+    def parse(self, s):
+        return _semantic_key(s)
+
+    @property
+    def is_prerelease(self):
+        return self._parts[1][0] != '|'
+
+
+class SemanticMatcher(Matcher):
+    version_class = SemanticVersion
+
+
+class VersionScheme(object):
+    def __init__(self, key, matcher, suggester=None):
+        self.key = key
+        self.matcher = matcher
+        self.suggester = suggester
+
+    def is_valid_version(self, s):
+        try:
+            self.matcher.version_class(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_matcher(self, s):
+        try:
+            self.matcher(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_constraint_list(self, s):
+        """
+        Used for processing some metadata fields
+        """
+        return self.is_valid_matcher('dummy_name (%s)' % s)
+
+    def suggest(self, s):
+        if self.suggester is None:
+            result = None
+        else:
+            result = self.suggester(s)
+        return result
+
+_SCHEMES = {
+    'normalized': VersionScheme(_normalized_key, NormalizedMatcher,
+                                _suggest_normalized_version),
+    'legacy': VersionScheme(_legacy_key, LegacyMatcher, lambda self, s: s),
+    'semantic': VersionScheme(_semantic_key, SemanticMatcher,
+                              _suggest_semantic_version),
+}
+
+_SCHEMES['default'] = _SCHEMES['normalized']
+
+
+def get_scheme(name):
+    if name not in _SCHEMES:
+        raise ValueError('unknown scheme name: %r' % name)
+    return _SCHEMES[name]
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5ba4bf123aa585ec8a47dce6838b09b4dfa0b1a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/__init__.py
@@ -0,0 +1,14 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from .py import Trie as PyTrie
+
+Trie = PyTrie
+
+# pylint:disable=wrong-import-position
+try:
+    from .datrie import Trie as DATrie
+except ImportError:
+    pass
+else:
+    Trie = DATrie
+# pylint:enable=wrong-import-position
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/_base.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b71975f08587ca8861acc2380f17701b7c7c656
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/_base.py
@@ -0,0 +1,40 @@
+from __future__ import absolute_import, division, unicode_literals
+
+try:
+    from collections.abc import Mapping
+except ImportError:  # Python 2.7
+    from collections import Mapping
+
+
+class Trie(Mapping):
+    """Abstract base class for tries"""
+
+    def keys(self, prefix=None):
+        # pylint:disable=arguments-differ
+        keys = super(Trie, self).keys()
+
+        if prefix is None:
+            return set(keys)
+
+        return {x for x in keys if x.startswith(prefix)}
+
+    def has_keys_with_prefix(self, prefix):
+        for key in self.keys():
+            if key.startswith(prefix):
+                return True
+
+        return False
+
+    def longest_prefix(self, prefix):
+        if prefix in self:
+            return prefix
+
+        for i in range(1, len(prefix) + 1):
+            if prefix[:-i] in self:
+                return prefix[:-i]
+
+        raise KeyError(prefix)
+
+    def longest_prefix_item(self, prefix):
+        lprefix = self.longest_prefix(prefix)
+        return (lprefix, self[lprefix])
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/datrie.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/datrie.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2e5f86621c3881d1d812814aec9d153dca34bd1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/datrie.py
@@ -0,0 +1,44 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from datrie import Trie as DATrie
+from pip._vendor.six import text_type
+
+from ._base import Trie as ABCTrie
+
+
+class Trie(ABCTrie):
+    def __init__(self, data):
+        chars = set()
+        for key in data.keys():
+            if not isinstance(key, text_type):
+                raise TypeError("All keys must be strings")
+            for char in key:
+                chars.add(char)
+
+        self._data = DATrie("".join(chars))
+        for key, value in data.items():
+            self._data[key] = value
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def __len__(self):
+        return len(self._data)
+
+    def __iter__(self):
+        raise NotImplementedError()
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def keys(self, prefix=None):
+        return self._data.keys(prefix)
+
+    def has_keys_with_prefix(self, prefix):
+        return self._data.has_keys_with_prefix(prefix)
+
+    def longest_prefix(self, prefix):
+        return self._data.longest_prefix(prefix)
+
+    def longest_prefix_item(self, prefix):
+        return self._data.longest_prefix_item(prefix)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/py.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/py.py
new file mode 100644
index 0000000000000000000000000000000000000000..c178b219def8f7fbfe6d00f7822a8e61293d003a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_trie/py.py
@@ -0,0 +1,67 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+from bisect import bisect_left
+
+from ._base import Trie as ABCTrie
+
+
+class Trie(ABCTrie):
+    def __init__(self, data):
+        if not all(isinstance(x, text_type) for x in data.keys()):
+            raise TypeError("All keys must be strings")
+
+        self._data = data
+        self._keys = sorted(data.keys())
+        self._cachestr = ""
+        self._cachepoints = (0, len(data))
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def __len__(self):
+        return len(self._data)
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def keys(self, prefix=None):
+        if prefix is None or prefix == "" or not self._keys:
+            return set(self._keys)
+
+        if prefix.startswith(self._cachestr):
+            lo, hi = self._cachepoints
+            start = i = bisect_left(self._keys, prefix, lo, hi)
+        else:
+            start = i = bisect_left(self._keys, prefix)
+
+        keys = set()
+        if start == len(self._keys):
+            return keys
+
+        while self._keys[i].startswith(prefix):
+            keys.add(self._keys[i])
+            i += 1
+
+        self._cachestr = prefix
+        self._cachepoints = (start, i)
+
+        return keys
+
+    def has_keys_with_prefix(self, prefix):
+        if prefix in self._data:
+            return True
+
+        if prefix.startswith(self._cachestr):
+            lo, hi = self._cachepoints
+            i = bisect_left(self._keys, prefix, lo, hi)
+        else:
+            i = bisect_left(self._keys, prefix)
+
+        if i == len(self._keys):
+            return False
+
+        return self._keys[i].startswith(prefix)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ba926e3b09a71121d3c10b962c26137221d5a34
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/alphabeticalattributes.py
@@ -0,0 +1,29 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+from collections import OrderedDict
+
+
+def _attr_key(attr):
+    """Return an appropriate key for an attribute for sorting
+
+    Attributes have a namespace that can be either ``None`` or a string. We
+    can't compare the two because they're different types, so we convert
+    ``None`` to an empty string first.
+
+    """
+    return (attr[0][0] or ''), attr[0][1]
+
+
+class Filter(base.Filter):
+    """Alphabetizes attributes for elements"""
+    def __iter__(self):
+        for token in base.Filter.__iter__(self):
+            if token["type"] in ("StartTag", "EmptyTag"):
+                attrs = OrderedDict()
+                for name, value in sorted(token["data"].items(),
+                                          key=_attr_key):
+                    attrs[name] = value
+                token["data"] = attrs
+            yield token
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/base.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7dbaed0fab5afb4f8947b24dd175d2239d35d6b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/base.py
@@ -0,0 +1,12 @@
+from __future__ import absolute_import, division, unicode_literals
+
+
+class Filter(object):
+    def __init__(self, source):
+        self.source = source
+
+    def __iter__(self):
+        return iter(self.source)
+
+    def __getattr__(self, name):
+        return getattr(self.source, name)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py
new file mode 100644
index 0000000000000000000000000000000000000000..aefb5c842c2f55075546065cfba3c66d137e8184
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/inject_meta_charset.py
@@ -0,0 +1,73 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+
+class Filter(base.Filter):
+    """Injects ``<meta charset=ENCODING>`` tag into head of document"""
+    def __init__(self, source, encoding):
+        """Creates a Filter
+
+        :arg source: the source token stream
+
+        :arg encoding: the encoding to set
+
+        """
+        base.Filter.__init__(self, source)
+        self.encoding = encoding
+
+    def __iter__(self):
+        state = "pre_head"
+        meta_found = (self.encoding is None)
+        pending = []
+
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type == "StartTag":
+                if token["name"].lower() == "head":
+                    state = "in_head"
+
+            elif type == "EmptyTag":
+                if token["name"].lower() == "meta":
+                    # replace charset with actual encoding
+                    has_http_equiv_content_type = False
+                    for (namespace, name), value in token["data"].items():
+                        if namespace is not None:
+                            continue
+                        elif name.lower() == 'charset':
+                            token["data"][(namespace, name)] = self.encoding
+                            meta_found = True
+                            break
+                        elif name == 'http-equiv' and value.lower() == 'content-type':
+                            has_http_equiv_content_type = True
+                    else:
+                        if has_http_equiv_content_type and (None, "content") in token["data"]:
+                            token["data"][(None, "content")] = 'text/html; charset=%s' % self.encoding
+                            meta_found = True
+
+                elif token["name"].lower() == "head" and not meta_found:
+                    # insert meta into empty head
+                    yield {"type": "StartTag", "name": "head",
+                           "data": token["data"]}
+                    yield {"type": "EmptyTag", "name": "meta",
+                           "data": {(None, "charset"): self.encoding}}
+                    yield {"type": "EndTag", "name": "head"}
+                    meta_found = True
+                    continue
+
+            elif type == "EndTag":
+                if token["name"].lower() == "head" and pending:
+                    # insert meta into head (if necessary) and flush pending queue
+                    yield pending.pop(0)
+                    if not meta_found:
+                        yield {"type": "EmptyTag", "name": "meta",
+                               "data": {(None, "charset"): self.encoding}}
+                    while pending:
+                        yield pending.pop(0)
+                    meta_found = True
+                    state = "post_head"
+
+            if state == "in_head":
+                pending.append(token)
+            else:
+                yield token
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/lint.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/lint.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcc07eec5b2e5ea926fa8b2af199e14c9cac50dd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/lint.py
@@ -0,0 +1,93 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from pip._vendor.six import text_type
+
+from . import base
+from ..constants import namespaces, voidElements
+
+from ..constants import spaceCharacters
+spaceCharacters = "".join(spaceCharacters)
+
+
+class Filter(base.Filter):
+    """Lints the token stream for errors
+
+    If it finds any errors, it'll raise an ``AssertionError``.
+
+    """
+    def __init__(self, source, require_matching_tags=True):
+        """Creates a Filter
+
+        :arg source: the source token stream
+
+        :arg require_matching_tags: whether or not to require matching tags
+
+        """
+        super(Filter, self).__init__(source)
+        self.require_matching_tags = require_matching_tags
+
+    def __iter__(self):
+        open_elements = []
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type in ("StartTag", "EmptyTag"):
+                namespace = token["namespace"]
+                name = token["name"]
+                assert namespace is None or isinstance(namespace, text_type)
+                assert namespace != ""
+                assert isinstance(name, text_type)
+                assert name != ""
+                assert isinstance(token["data"], dict)
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    assert type == "EmptyTag"
+                else:
+                    assert type == "StartTag"
+                if type == "StartTag" and self.require_matching_tags:
+                    open_elements.append((namespace, name))
+                for (namespace, name), value in token["data"].items():
+                    assert namespace is None or isinstance(namespace, text_type)
+                    assert namespace != ""
+                    assert isinstance(name, text_type)
+                    assert name != ""
+                    assert isinstance(value, text_type)
+
+            elif type == "EndTag":
+                namespace = token["namespace"]
+                name = token["name"]
+                assert namespace is None or isinstance(namespace, text_type)
+                assert namespace != ""
+                assert isinstance(name, text_type)
+                assert name != ""
+                if (not namespace or namespace == namespaces["html"]) and name in voidElements:
+                    assert False, "Void element reported as EndTag token: %(tag)s" % {"tag": name}
+                elif self.require_matching_tags:
+                    start = open_elements.pop()
+                    assert start == (namespace, name)
+
+            elif type == "Comment":
+                data = token["data"]
+                assert isinstance(data, text_type)
+
+            elif type in ("Characters", "SpaceCharacters"):
+                data = token["data"]
+                assert isinstance(data, text_type)
+                assert data != ""
+                if type == "SpaceCharacters":
+                    assert data.strip(spaceCharacters) == ""
+
+            elif type == "Doctype":
+                name = token["name"]
+                assert name is None or isinstance(name, text_type)
+                assert token["publicId"] is None or isinstance(name, text_type)
+                assert token["systemId"] is None or isinstance(name, text_type)
+
+            elif type == "Entity":
+                assert isinstance(token["name"], text_type)
+
+            elif type == "SerializerError":
+                assert isinstance(token["data"], text_type)
+
+            else:
+                assert False, "Unknown token type: %(type)s" % {"type": type}
+
+            yield token
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/optionaltags.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/optionaltags.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a865012c16237c3c4dd3404af7ed767b98d235a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/optionaltags.py
@@ -0,0 +1,207 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from . import base
+
+
+class Filter(base.Filter):
+    """Removes optional tags from the token stream"""
+    def slider(self):
+        previous1 = previous2 = None
+        for token in self.source:
+            if previous1 is not None:
+                yield previous2, previous1, token
+            previous2 = previous1
+            previous1 = token
+        if previous1 is not None:
+            yield previous2, previous1, None
+
+    def __iter__(self):
+        for previous, token, next in self.slider():
+            type = token["type"]
+            if type == "StartTag":
+                if (token["data"] or
+                        not self.is_optional_start(token["name"], previous, next)):
+                    yield token
+            elif type == "EndTag":
+                if not self.is_optional_end(token["name"], next):
+                    yield token
+            else:
+                yield token
+
+    def is_optional_start(self, tagname, previous, next):
+        type = next and next["type"] or None
+        if tagname in 'html':
+            # An html element's start tag may be omitted if the first thing
+            # inside the html element is not a space character or a comment.
+            return type not in ("Comment", "SpaceCharacters")
+        elif tagname == 'head':
+            # A head element's start tag may be omitted if the first thing
+            # inside the head element is an element.
+            # XXX: we also omit the start tag if the head element is empty
+            if type in ("StartTag", "EmptyTag"):
+                return True
+            elif type == "EndTag":
+                return next["name"] == "head"
+        elif tagname == 'body':
+            # A body element's start tag may be omitted if the first thing
+            # inside the body element is not a space character or a comment,
+            # except if the first thing inside the body element is a script
+            # or style element and the node immediately preceding the body
+            # element is a head element whose end tag has been omitted.
+            if type in ("Comment", "SpaceCharacters"):
+                return False
+            elif type == "StartTag":
+                # XXX: we do not look at the preceding event, so we never omit
+                # the body element's start tag if it's followed by a script or
+                # a style element.
+                return next["name"] not in ('script', 'style')
+            else:
+                return True
+        elif tagname == 'colgroup':
+            # A colgroup element's start tag may be omitted if the first thing
+            # inside the colgroup element is a col element, and if the element
+            # is not immediately preceded by another colgroup element whose
+            # end tag has been omitted.
+            if type in ("StartTag", "EmptyTag"):
+                # XXX: we do not look at the preceding event, so instead we never
+                # omit the colgroup element's end tag when it is immediately
+                # followed by another colgroup element. See is_optional_end.
+                return next["name"] == "col"
+            else:
+                return False
+        elif tagname == 'tbody':
+            # A tbody element's start tag may be omitted if the first thing
+            # inside the tbody element is a tr element, and if the element is
+            # not immediately preceded by a tbody, thead, or tfoot element
+            # whose end tag has been omitted.
+            if type == "StartTag":
+                # omit the thead and tfoot elements' end tag when they are
+                # immediately followed by a tbody element. See is_optional_end.
+                if previous and previous['type'] == 'EndTag' and \
+                        previous['name'] in ('tbody', 'thead', 'tfoot'):
+                    return False
+                return next["name"] == 'tr'
+            else:
+                return False
+        return False
+
+    def is_optional_end(self, tagname, next):
+        type = next and next["type"] or None
+        if tagname in ('html', 'head', 'body'):
+            # An html element's end tag may be omitted if the html element
+            # is not immediately followed by a space character or a comment.
+            return type not in ("Comment", "SpaceCharacters")
+        elif tagname in ('li', 'optgroup', 'tr'):
+            # A li element's end tag may be omitted if the li element is
+            # immediately followed by another li element or if there is
+            # no more content in the parent element.
+            # An optgroup element's end tag may be omitted if the optgroup
+            # element is immediately followed by another optgroup element,
+            # or if there is no more content in the parent element.
+            # A tr element's end tag may be omitted if the tr element is
+            # immediately followed by another tr element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] == tagname
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('dt', 'dd'):
+            # A dt element's end tag may be omitted if the dt element is
+            # immediately followed by another dt element or a dd element.
+            # A dd element's end tag may be omitted if the dd element is
+            # immediately followed by another dd element or a dt element,
+            # or if there is no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('dt', 'dd')
+            elif tagname == 'dd':
+                return type == "EndTag" or type is None
+            else:
+                return False
+        elif tagname == 'p':
+            # A p element's end tag may be omitted if the p element is
+            # immediately followed by an address, article, aside,
+            # blockquote, datagrid, dialog, dir, div, dl, fieldset,
+            # footer, form, h1, h2, h3, h4, h5, h6, header, hr, menu,
+            # nav, ol, p, pre, section, table, or ul, element, or if
+            # there is no more content in the parent element.
+            if type in ("StartTag", "EmptyTag"):
+                return next["name"] in ('address', 'article', 'aside',
+                                        'blockquote', 'datagrid', 'dialog',
+                                        'dir', 'div', 'dl', 'fieldset', 'footer',
+                                        'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+                                        'header', 'hr', 'menu', 'nav', 'ol',
+                                        'p', 'pre', 'section', 'table', 'ul')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname == 'option':
+            # An option element's end tag may be omitted if the option
+            # element is immediately followed by another option element,
+            # or if it is immediately followed by an <code>optgroup</code>
+            # element, or if there is no more content in the parent
+            # element.
+            if type == "StartTag":
+                return next["name"] in ('option', 'optgroup')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('rt', 'rp'):
+            # An rt element's end tag may be omitted if the rt element is
+            # immediately followed by an rt or rp element, or if there is
+            # no more content in the parent element.
+            # An rp element's end tag may be omitted if the rp element is
+            # immediately followed by an rt or rp element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('rt', 'rp')
+            else:
+                return type == "EndTag" or type is None
+        elif tagname == 'colgroup':
+            # A colgroup element's end tag may be omitted if the colgroup
+            # element is not immediately followed by a space character or
+            # a comment.
+            if type in ("Comment", "SpaceCharacters"):
+                return False
+            elif type == "StartTag":
+                # XXX: we also look for an immediately following colgroup
+                # element. See is_optional_start.
+                return next["name"] != 'colgroup'
+            else:
+                return True
+        elif tagname in ('thead', 'tbody'):
+            # A thead element's end tag may be omitted if the thead element
+            # is immediately followed by a tbody or tfoot element.
+            # A tbody element's end tag may be omitted if the tbody element
+            # is immediately followed by a tbody or tfoot element, or if
+            # there is no more content in the parent element.
+            # A tfoot element's end tag may be omitted if the tfoot element
+            # is immediately followed by a tbody element, or if there is no
+            # more content in the parent element.
+            # XXX: we never omit the end tag when the following element is
+            # a tbody. See is_optional_start.
+            if type == "StartTag":
+                return next["name"] in ['tbody', 'tfoot']
+            elif tagname == 'tbody':
+                return type == "EndTag" or type is None
+            else:
+                return False
+        elif tagname == 'tfoot':
+            # A tfoot element's end tag may be omitted if the tfoot element
+            # is immediately followed by a tbody element, or if there is no
+            # more content in the parent element.
+            # XXX: we never omit the end tag when the following element is
+            # a tbody. See is_optional_start.
+            if type == "StartTag":
+                return next["name"] == 'tbody'
+            else:
+                return type == "EndTag" or type is None
+        elif tagname in ('td', 'th'):
+            # A td element's end tag may be omitted if the td element is
+            # immediately followed by a td or th element, or if there is
+            # no more content in the parent element.
+            # A th element's end tag may be omitted if the th element is
+            # immediately followed by a td or th element, or if there is
+            # no more content in the parent element.
+            if type == "StartTag":
+                return next["name"] in ('td', 'th')
+            else:
+                return type == "EndTag" or type is None
+        return False
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/sanitizer.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/sanitizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..af8e77b81e373c4639114f764daa6e182dce1422
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/sanitizer.py
@@ -0,0 +1,896 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import re
+from xml.sax.saxutils import escape, unescape
+
+from pip._vendor.six.moves import urllib_parse as urlparse
+
+from . import base
+from ..constants import namespaces, prefixes
+
+__all__ = ["Filter"]
+
+
+allowed_elements = frozenset((
+    (namespaces['html'], 'a'),
+    (namespaces['html'], 'abbr'),
+    (namespaces['html'], 'acronym'),
+    (namespaces['html'], 'address'),
+    (namespaces['html'], 'area'),
+    (namespaces['html'], 'article'),
+    (namespaces['html'], 'aside'),
+    (namespaces['html'], 'audio'),
+    (namespaces['html'], 'b'),
+    (namespaces['html'], 'big'),
+    (namespaces['html'], 'blockquote'),
+    (namespaces['html'], 'br'),
+    (namespaces['html'], 'button'),
+    (namespaces['html'], 'canvas'),
+    (namespaces['html'], 'caption'),
+    (namespaces['html'], 'center'),
+    (namespaces['html'], 'cite'),
+    (namespaces['html'], 'code'),
+    (namespaces['html'], 'col'),
+    (namespaces['html'], 'colgroup'),
+    (namespaces['html'], 'command'),
+    (namespaces['html'], 'datagrid'),
+    (namespaces['html'], 'datalist'),
+    (namespaces['html'], 'dd'),
+    (namespaces['html'], 'del'),
+    (namespaces['html'], 'details'),
+    (namespaces['html'], 'dfn'),
+    (namespaces['html'], 'dialog'),
+    (namespaces['html'], 'dir'),
+    (namespaces['html'], 'div'),
+    (namespaces['html'], 'dl'),
+    (namespaces['html'], 'dt'),
+    (namespaces['html'], 'em'),
+    (namespaces['html'], 'event-source'),
+    (namespaces['html'], 'fieldset'),
+    (namespaces['html'], 'figcaption'),
+    (namespaces['html'], 'figure'),
+    (namespaces['html'], 'footer'),
+    (namespaces['html'], 'font'),
+    (namespaces['html'], 'form'),
+    (namespaces['html'], 'header'),
+    (namespaces['html'], 'h1'),
+    (namespaces['html'], 'h2'),
+    (namespaces['html'], 'h3'),
+    (namespaces['html'], 'h4'),
+    (namespaces['html'], 'h5'),
+    (namespaces['html'], 'h6'),
+    (namespaces['html'], 'hr'),
+    (namespaces['html'], 'i'),
+    (namespaces['html'], 'img'),
+    (namespaces['html'], 'input'),
+    (namespaces['html'], 'ins'),
+    (namespaces['html'], 'keygen'),
+    (namespaces['html'], 'kbd'),
+    (namespaces['html'], 'label'),
+    (namespaces['html'], 'legend'),
+    (namespaces['html'], 'li'),
+    (namespaces['html'], 'm'),
+    (namespaces['html'], 'map'),
+    (namespaces['html'], 'menu'),
+    (namespaces['html'], 'meter'),
+    (namespaces['html'], 'multicol'),
+    (namespaces['html'], 'nav'),
+    (namespaces['html'], 'nextid'),
+    (namespaces['html'], 'ol'),
+    (namespaces['html'], 'output'),
+    (namespaces['html'], 'optgroup'),
+    (namespaces['html'], 'option'),
+    (namespaces['html'], 'p'),
+    (namespaces['html'], 'pre'),
+    (namespaces['html'], 'progress'),
+    (namespaces['html'], 'q'),
+    (namespaces['html'], 's'),
+    (namespaces['html'], 'samp'),
+    (namespaces['html'], 'section'),
+    (namespaces['html'], 'select'),
+    (namespaces['html'], 'small'),
+    (namespaces['html'], 'sound'),
+    (namespaces['html'], 'source'),
+    (namespaces['html'], 'spacer'),
+    (namespaces['html'], 'span'),
+    (namespaces['html'], 'strike'),
+    (namespaces['html'], 'strong'),
+    (namespaces['html'], 'sub'),
+    (namespaces['html'], 'sup'),
+    (namespaces['html'], 'table'),
+    (namespaces['html'], 'tbody'),
+    (namespaces['html'], 'td'),
+    (namespaces['html'], 'textarea'),
+    (namespaces['html'], 'time'),
+    (namespaces['html'], 'tfoot'),
+    (namespaces['html'], 'th'),
+    (namespaces['html'], 'thead'),
+    (namespaces['html'], 'tr'),
+    (namespaces['html'], 'tt'),
+    (namespaces['html'], 'u'),
+    (namespaces['html'], 'ul'),
+    (namespaces['html'], 'var'),
+    (namespaces['html'], 'video'),
+    (namespaces['mathml'], 'maction'),
+    (namespaces['mathml'], 'math'),
+    (namespaces['mathml'], 'merror'),
+    (namespaces['mathml'], 'mfrac'),
+    (namespaces['mathml'], 'mi'),
+    (namespaces['mathml'], 'mmultiscripts'),
+    (namespaces['mathml'], 'mn'),
+    (namespaces['mathml'], 'mo'),
+    (namespaces['mathml'], 'mover'),
+    (namespaces['mathml'], 'mpadded'),
+    (namespaces['mathml'], 'mphantom'),
+    (namespaces['mathml'], 'mprescripts'),
+    (namespaces['mathml'], 'mroot'),
+    (namespaces['mathml'], 'mrow'),
+    (namespaces['mathml'], 'mspace'),
+    (namespaces['mathml'], 'msqrt'),
+    (namespaces['mathml'], 'mstyle'),
+    (namespaces['mathml'], 'msub'),
+    (namespaces['mathml'], 'msubsup'),
+    (namespaces['mathml'], 'msup'),
+    (namespaces['mathml'], 'mtable'),
+    (namespaces['mathml'], 'mtd'),
+    (namespaces['mathml'], 'mtext'),
+    (namespaces['mathml'], 'mtr'),
+    (namespaces['mathml'], 'munder'),
+    (namespaces['mathml'], 'munderover'),
+    (namespaces['mathml'], 'none'),
+    (namespaces['svg'], 'a'),
+    (namespaces['svg'], 'animate'),
+    (namespaces['svg'], 'animateColor'),
+    (namespaces['svg'], 'animateMotion'),
+    (namespaces['svg'], 'animateTransform'),
+    (namespaces['svg'], 'clipPath'),
+    (namespaces['svg'], 'circle'),
+    (namespaces['svg'], 'defs'),
+    (namespaces['svg'], 'desc'),
+    (namespaces['svg'], 'ellipse'),
+    (namespaces['svg'], 'font-face'),
+    (namespaces['svg'], 'font-face-name'),
+    (namespaces['svg'], 'font-face-src'),
+    (namespaces['svg'], 'g'),
+    (namespaces['svg'], 'glyph'),
+    (namespaces['svg'], 'hkern'),
+    (namespaces['svg'], 'linearGradient'),
+    (namespaces['svg'], 'line'),
+    (namespaces['svg'], 'marker'),
+    (namespaces['svg'], 'metadata'),
+    (namespaces['svg'], 'missing-glyph'),
+    (namespaces['svg'], 'mpath'),
+    (namespaces['svg'], 'path'),
+    (namespaces['svg'], 'polygon'),
+    (namespaces['svg'], 'polyline'),
+    (namespaces['svg'], 'radialGradient'),
+    (namespaces['svg'], 'rect'),
+    (namespaces['svg'], 'set'),
+    (namespaces['svg'], 'stop'),
+    (namespaces['svg'], 'svg'),
+    (namespaces['svg'], 'switch'),
+    (namespaces['svg'], 'text'),
+    (namespaces['svg'], 'title'),
+    (namespaces['svg'], 'tspan'),
+    (namespaces['svg'], 'use'),
+))
+
+allowed_attributes = frozenset((
+    # HTML attributes
+    (None, 'abbr'),
+    (None, 'accept'),
+    (None, 'accept-charset'),
+    (None, 'accesskey'),
+    (None, 'action'),
+    (None, 'align'),
+    (None, 'alt'),
+    (None, 'autocomplete'),
+    (None, 'autofocus'),
+    (None, 'axis'),
+    (None, 'background'),
+    (None, 'balance'),
+    (None, 'bgcolor'),
+    (None, 'bgproperties'),
+    (None, 'border'),
+    (None, 'bordercolor'),
+    (None, 'bordercolordark'),
+    (None, 'bordercolorlight'),
+    (None, 'bottompadding'),
+    (None, 'cellpadding'),
+    (None, 'cellspacing'),
+    (None, 'ch'),
+    (None, 'challenge'),
+    (None, 'char'),
+    (None, 'charoff'),
+    (None, 'choff'),
+    (None, 'charset'),
+    (None, 'checked'),
+    (None, 'cite'),
+    (None, 'class'),
+    (None, 'clear'),
+    (None, 'color'),
+    (None, 'cols'),
+    (None, 'colspan'),
+    (None, 'compact'),
+    (None, 'contenteditable'),
+    (None, 'controls'),
+    (None, 'coords'),
+    (None, 'data'),
+    (None, 'datafld'),
+    (None, 'datapagesize'),
+    (None, 'datasrc'),
+    (None, 'datetime'),
+    (None, 'default'),
+    (None, 'delay'),
+    (None, 'dir'),
+    (None, 'disabled'),
+    (None, 'draggable'),
+    (None, 'dynsrc'),
+    (None, 'enctype'),
+    (None, 'end'),
+    (None, 'face'),
+    (None, 'for'),
+    (None, 'form'),
+    (None, 'frame'),
+    (None, 'galleryimg'),
+    (None, 'gutter'),
+    (None, 'headers'),
+    (None, 'height'),
+    (None, 'hidefocus'),
+    (None, 'hidden'),
+    (None, 'high'),
+    (None, 'href'),
+    (None, 'hreflang'),
+    (None, 'hspace'),
+    (None, 'icon'),
+    (None, 'id'),
+    (None, 'inputmode'),
+    (None, 'ismap'),
+    (None, 'keytype'),
+    (None, 'label'),
+    (None, 'leftspacing'),
+    (None, 'lang'),
+    (None, 'list'),
+    (None, 'longdesc'),
+    (None, 'loop'),
+    (None, 'loopcount'),
+    (None, 'loopend'),
+    (None, 'loopstart'),
+    (None, 'low'),
+    (None, 'lowsrc'),
+    (None, 'max'),
+    (None, 'maxlength'),
+    (None, 'media'),
+    (None, 'method'),
+    (None, 'min'),
+    (None, 'multiple'),
+    (None, 'name'),
+    (None, 'nohref'),
+    (None, 'noshade'),
+    (None, 'nowrap'),
+    (None, 'open'),
+    (None, 'optimum'),
+    (None, 'pattern'),
+    (None, 'ping'),
+    (None, 'point-size'),
+    (None, 'poster'),
+    (None, 'pqg'),
+    (None, 'preload'),
+    (None, 'prompt'),
+    (None, 'radiogroup'),
+    (None, 'readonly'),
+    (None, 'rel'),
+    (None, 'repeat-max'),
+    (None, 'repeat-min'),
+    (None, 'replace'),
+    (None, 'required'),
+    (None, 'rev'),
+    (None, 'rightspacing'),
+    (None, 'rows'),
+    (None, 'rowspan'),
+    (None, 'rules'),
+    (None, 'scope'),
+    (None, 'selected'),
+    (None, 'shape'),
+    (None, 'size'),
+    (None, 'span'),
+    (None, 'src'),
+    (None, 'start'),
+    (None, 'step'),
+    (None, 'style'),
+    (None, 'summary'),
+    (None, 'suppress'),
+    (None, 'tabindex'),
+    (None, 'target'),
+    (None, 'template'),
+    (None, 'title'),
+    (None, 'toppadding'),
+    (None, 'type'),
+    (None, 'unselectable'),
+    (None, 'usemap'),
+    (None, 'urn'),
+    (None, 'valign'),
+    (None, 'value'),
+    (None, 'variable'),
+    (None, 'volume'),
+    (None, 'vspace'),
+    (None, 'vrml'),
+    (None, 'width'),
+    (None, 'wrap'),
+    (namespaces['xml'], 'lang'),
+    # MathML attributes
+    (None, 'actiontype'),
+    (None, 'align'),
+    (None, 'columnalign'),
+    (None, 'columnalign'),
+    (None, 'columnalign'),
+    (None, 'columnlines'),
+    (None, 'columnspacing'),
+    (None, 'columnspan'),
+    (None, 'depth'),
+    (None, 'display'),
+    (None, 'displaystyle'),
+    (None, 'equalcolumns'),
+    (None, 'equalrows'),
+    (None, 'fence'),
+    (None, 'fontstyle'),
+    (None, 'fontweight'),
+    (None, 'frame'),
+    (None, 'height'),
+    (None, 'linethickness'),
+    (None, 'lspace'),
+    (None, 'mathbackground'),
+    (None, 'mathcolor'),
+    (None, 'mathvariant'),
+    (None, 'mathvariant'),
+    (None, 'maxsize'),
+    (None, 'minsize'),
+    (None, 'other'),
+    (None, 'rowalign'),
+    (None, 'rowalign'),
+    (None, 'rowalign'),
+    (None, 'rowlines'),
+    (None, 'rowspacing'),
+    (None, 'rowspan'),
+    (None, 'rspace'),
+    (None, 'scriptlevel'),
+    (None, 'selection'),
+    (None, 'separator'),
+    (None, 'stretchy'),
+    (None, 'width'),
+    (None, 'width'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xlink'], 'show'),
+    (namespaces['xlink'], 'type'),
+    # SVG attributes
+    (None, 'accent-height'),
+    (None, 'accumulate'),
+    (None, 'additive'),
+    (None, 'alphabetic'),
+    (None, 'arabic-form'),
+    (None, 'ascent'),
+    (None, 'attributeName'),
+    (None, 'attributeType'),
+    (None, 'baseProfile'),
+    (None, 'bbox'),
+    (None, 'begin'),
+    (None, 'by'),
+    (None, 'calcMode'),
+    (None, 'cap-height'),
+    (None, 'class'),
+    (None, 'clip-path'),
+    (None, 'color'),
+    (None, 'color-rendering'),
+    (None, 'content'),
+    (None, 'cx'),
+    (None, 'cy'),
+    (None, 'd'),
+    (None, 'dx'),
+    (None, 'dy'),
+    (None, 'descent'),
+    (None, 'display'),
+    (None, 'dur'),
+    (None, 'end'),
+    (None, 'fill'),
+    (None, 'fill-opacity'),
+    (None, 'fill-rule'),
+    (None, 'font-family'),
+    (None, 'font-size'),
+    (None, 'font-stretch'),
+    (None, 'font-style'),
+    (None, 'font-variant'),
+    (None, 'font-weight'),
+    (None, 'from'),
+    (None, 'fx'),
+    (None, 'fy'),
+    (None, 'g1'),
+    (None, 'g2'),
+    (None, 'glyph-name'),
+    (None, 'gradientUnits'),
+    (None, 'hanging'),
+    (None, 'height'),
+    (None, 'horiz-adv-x'),
+    (None, 'horiz-origin-x'),
+    (None, 'id'),
+    (None, 'ideographic'),
+    (None, 'k'),
+    (None, 'keyPoints'),
+    (None, 'keySplines'),
+    (None, 'keyTimes'),
+    (None, 'lang'),
+    (None, 'marker-end'),
+    (None, 'marker-mid'),
+    (None, 'marker-start'),
+    (None, 'markerHeight'),
+    (None, 'markerUnits'),
+    (None, 'markerWidth'),
+    (None, 'mathematical'),
+    (None, 'max'),
+    (None, 'min'),
+    (None, 'name'),
+    (None, 'offset'),
+    (None, 'opacity'),
+    (None, 'orient'),
+    (None, 'origin'),
+    (None, 'overline-position'),
+    (None, 'overline-thickness'),
+    (None, 'panose-1'),
+    (None, 'path'),
+    (None, 'pathLength'),
+    (None, 'points'),
+    (None, 'preserveAspectRatio'),
+    (None, 'r'),
+    (None, 'refX'),
+    (None, 'refY'),
+    (None, 'repeatCount'),
+    (None, 'repeatDur'),
+    (None, 'requiredExtensions'),
+    (None, 'requiredFeatures'),
+    (None, 'restart'),
+    (None, 'rotate'),
+    (None, 'rx'),
+    (None, 'ry'),
+    (None, 'slope'),
+    (None, 'stemh'),
+    (None, 'stemv'),
+    (None, 'stop-color'),
+    (None, 'stop-opacity'),
+    (None, 'strikethrough-position'),
+    (None, 'strikethrough-thickness'),
+    (None, 'stroke'),
+    (None, 'stroke-dasharray'),
+    (None, 'stroke-dashoffset'),
+    (None, 'stroke-linecap'),
+    (None, 'stroke-linejoin'),
+    (None, 'stroke-miterlimit'),
+    (None, 'stroke-opacity'),
+    (None, 'stroke-width'),
+    (None, 'systemLanguage'),
+    (None, 'target'),
+    (None, 'text-anchor'),
+    (None, 'to'),
+    (None, 'transform'),
+    (None, 'type'),
+    (None, 'u1'),
+    (None, 'u2'),
+    (None, 'underline-position'),
+    (None, 'underline-thickness'),
+    (None, 'unicode'),
+    (None, 'unicode-range'),
+    (None, 'units-per-em'),
+    (None, 'values'),
+    (None, 'version'),
+    (None, 'viewBox'),
+    (None, 'visibility'),
+    (None, 'width'),
+    (None, 'widths'),
+    (None, 'x'),
+    (None, 'x-height'),
+    (None, 'x1'),
+    (None, 'x2'),
+    (namespaces['xlink'], 'actuate'),
+    (namespaces['xlink'], 'arcrole'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xlink'], 'role'),
+    (namespaces['xlink'], 'show'),
+    (namespaces['xlink'], 'title'),
+    (namespaces['xlink'], 'type'),
+    (namespaces['xml'], 'base'),
+    (namespaces['xml'], 'lang'),
+    (namespaces['xml'], 'space'),
+    (None, 'y'),
+    (None, 'y1'),
+    (None, 'y2'),
+    (None, 'zoomAndPan'),
+))
+
+attr_val_is_uri = frozenset((
+    (None, 'href'),
+    (None, 'src'),
+    (None, 'cite'),
+    (None, 'action'),
+    (None, 'longdesc'),
+    (None, 'poster'),
+    (None, 'background'),
+    (None, 'datasrc'),
+    (None, 'dynsrc'),
+    (None, 'lowsrc'),
+    (None, 'ping'),
+    (namespaces['xlink'], 'href'),
+    (namespaces['xml'], 'base'),
+))
+
+svg_attr_val_allows_ref = frozenset((
+    (None, 'clip-path'),
+    (None, 'color-profile'),
+    (None, 'cursor'),
+    (None, 'fill'),
+    (None, 'filter'),
+    (None, 'marker'),
+    (None, 'marker-start'),
+    (None, 'marker-mid'),
+    (None, 'marker-end'),
+    (None, 'mask'),
+    (None, 'stroke'),
+))
+
+svg_allow_local_href = frozenset((
+    (None, 'altGlyph'),
+    (None, 'animate'),
+    (None, 'animateColor'),
+    (None, 'animateMotion'),
+    (None, 'animateTransform'),
+    (None, 'cursor'),
+    (None, 'feImage'),
+    (None, 'filter'),
+    (None, 'linearGradient'),
+    (None, 'pattern'),
+    (None, 'radialGradient'),
+    (None, 'textpath'),
+    (None, 'tref'),
+    (None, 'set'),
+    (None, 'use')
+))
+
+allowed_css_properties = frozenset((
+    'azimuth',
+    'background-color',
+    'border-bottom-color',
+    'border-collapse',
+    'border-color',
+    'border-left-color',
+    'border-right-color',
+    'border-top-color',
+    'clear',
+    'color',
+    'cursor',
+    'direction',
+    'display',
+    'elevation',
+    'float',
+    'font',
+    'font-family',
+    'font-size',
+    'font-style',
+    'font-variant',
+    'font-weight',
+    'height',
+    'letter-spacing',
+    'line-height',
+    'overflow',
+    'pause',
+    'pause-after',
+    'pause-before',
+    'pitch',
+    'pitch-range',
+    'richness',
+    'speak',
+    'speak-header',
+    'speak-numeral',
+    'speak-punctuation',
+    'speech-rate',
+    'stress',
+    'text-align',
+    'text-decoration',
+    'text-indent',
+    'unicode-bidi',
+    'vertical-align',
+    'voice-family',
+    'volume',
+    'white-space',
+    'width',
+))
+
+allowed_css_keywords = frozenset((
+    'auto',
+    'aqua',
+    'black',
+    'block',
+    'blue',
+    'bold',
+    'both',
+    'bottom',
+    'brown',
+    'center',
+    'collapse',
+    'dashed',
+    'dotted',
+    'fuchsia',
+    'gray',
+    'green',
+    '!important',
+    'italic',
+    'left',
+    'lime',
+    'maroon',
+    'medium',
+    'none',
+    'navy',
+    'normal',
+    'nowrap',
+    'olive',
+    'pointer',
+    'purple',
+    'red',
+    'right',
+    'solid',
+    'silver',
+    'teal',
+    'top',
+    'transparent',
+    'underline',
+    'white',
+    'yellow',
+))
+
+allowed_svg_properties = frozenset((
+    'fill',
+    'fill-opacity',
+    'fill-rule',
+    'stroke',
+    'stroke-width',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-opacity',
+))
+
+allowed_protocols = frozenset((
+    'ed2k',
+    'ftp',
+    'http',
+    'https',
+    'irc',
+    'mailto',
+    'news',
+    'gopher',
+    'nntp',
+    'telnet',
+    'webcal',
+    'xmpp',
+    'callto',
+    'feed',
+    'urn',
+    'aim',
+    'rsync',
+    'tag',
+    'ssh',
+    'sftp',
+    'rtsp',
+    'afs',
+    'data',
+))
+
+allowed_content_types = frozenset((
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+    'image/bmp',
+    'text/plain',
+))
+
+
+data_content_type = re.compile(r'''
+                                ^
+                                # Match a content type <application>/<type>
+                                (?P<content_type>[-a-zA-Z0-9.]+/[-a-zA-Z0-9.]+)
+                                # Match any character set and encoding
+                                (?:(?:;charset=(?:[-a-zA-Z0-9]+)(?:;(?:base64))?)
+                                  |(?:;(?:base64))?(?:;charset=(?:[-a-zA-Z0-9]+))?)
+                                # Assume the rest is data
+                                ,.*
+                                $
+                                ''',
+                               re.VERBOSE)
+
+
+class Filter(base.Filter):
+    """Sanitizes token stream of XHTML+MathML+SVG and of inline style attributes"""
+    def __init__(self,
+                 source,
+                 allowed_elements=allowed_elements,
+                 allowed_attributes=allowed_attributes,
+                 allowed_css_properties=allowed_css_properties,
+                 allowed_css_keywords=allowed_css_keywords,
+                 allowed_svg_properties=allowed_svg_properties,
+                 allowed_protocols=allowed_protocols,
+                 allowed_content_types=allowed_content_types,
+                 attr_val_is_uri=attr_val_is_uri,
+                 svg_attr_val_allows_ref=svg_attr_val_allows_ref,
+                 svg_allow_local_href=svg_allow_local_href):
+        """Creates a Filter
+
+        :arg allowed_elements: set of elements to allow--everything else will
+            be escaped
+
+        :arg allowed_attributes: set of attributes to allow in
+            elements--everything else will be stripped
+
+        :arg allowed_css_properties: set of CSS properties to allow--everything
+            else will be stripped
+
+        :arg allowed_css_keywords: set of CSS keywords to allow--everything
+            else will be stripped
+
+        :arg allowed_svg_properties: set of SVG properties to allow--everything
+            else will be removed
+
+        :arg allowed_protocols: set of allowed protocols for URIs
+
+        :arg allowed_content_types: set of allowed content types for ``data`` URIs.
+
+        :arg attr_val_is_uri: set of attributes that have URI values--values
+            that have a scheme not listed in ``allowed_protocols`` are removed
+
+        :arg svg_attr_val_allows_ref: set of SVG attributes that can have
+            references
+
+        :arg svg_allow_local_href: set of SVG elements that can have local
+            hrefs--these are removed
+
+        """
+        super(Filter, self).__init__(source)
+        self.allowed_elements = allowed_elements
+        self.allowed_attributes = allowed_attributes
+        self.allowed_css_properties = allowed_css_properties
+        self.allowed_css_keywords = allowed_css_keywords
+        self.allowed_svg_properties = allowed_svg_properties
+        self.allowed_protocols = allowed_protocols
+        self.allowed_content_types = allowed_content_types
+        self.attr_val_is_uri = attr_val_is_uri
+        self.svg_attr_val_allows_ref = svg_attr_val_allows_ref
+        self.svg_allow_local_href = svg_allow_local_href
+
+    def __iter__(self):
+        for token in base.Filter.__iter__(self):
+            token = self.sanitize_token(token)
+            if token:
+                yield token
+
+    # Sanitize the +html+, escaping all elements not in ALLOWED_ELEMENTS, and
+    # stripping out all attributes not in ALLOWED_ATTRIBUTES. Style attributes
+    # are parsed, and a restricted set, specified by ALLOWED_CSS_PROPERTIES and
+    # ALLOWED_CSS_KEYWORDS, are allowed through. attributes in ATTR_VAL_IS_URI
+    # are scanned, and only URI schemes specified in ALLOWED_PROTOCOLS are
+    # allowed.
+    #
+    #   sanitize_html('<script> do_nasty_stuff() </script>')
+    #    => &lt;script> do_nasty_stuff() &lt;/script>
+    #   sanitize_html('<a href="javascript: sucker();">Click here for $100</a>')
+    #    => <a>Click here for $100</a>
+    def sanitize_token(self, token):
+
+        # accommodate filters which use token_type differently
+        token_type = token["type"]
+        if token_type in ("StartTag", "EndTag", "EmptyTag"):
+            name = token["name"]
+            namespace = token["namespace"]
+            if ((namespace, name) in self.allowed_elements or
+                (namespace is None and
+                 (namespaces["html"], name) in self.allowed_elements)):
+                return self.allowed_token(token)
+            else:
+                return self.disallowed_token(token)
+        elif token_type == "Comment":
+            pass
+        else:
+            return token
+
+    def allowed_token(self, token):
+        if "data" in token:
+            attrs = token["data"]
+            attr_names = set(attrs.keys())
+
+            # Remove forbidden attributes
+            for to_remove in (attr_names - self.allowed_attributes):
+                del token["data"][to_remove]
+                attr_names.remove(to_remove)
+
+            # Remove attributes with disallowed URL values
+            for attr in (attr_names & self.attr_val_is_uri):
+                assert attr in attrs
+                # I don't have a clue where this regexp comes from or why it matches those
+                # characters, nor why we call unescape. I just know it's always been here.
+                # Should you be worried by this comment in a sanitizer? Yes. On the other hand, all
+                # this will do is remove *more* than it otherwise would.
+                val_unescaped = re.sub("[`\x00-\x20\x7f-\xa0\\s]+", '',
+                                       unescape(attrs[attr])).lower()
+                # remove replacement characters from unescaped characters
+                val_unescaped = val_unescaped.replace("\ufffd", "")
+                try:
+                    uri = urlparse.urlparse(val_unescaped)
+                except ValueError:
+                    uri = None
+                    del attrs[attr]
+                if uri and uri.scheme:
+                    if uri.scheme not in self.allowed_protocols:
+                        del attrs[attr]
+                    if uri.scheme == 'data':
+                        m = data_content_type.match(uri.path)
+                        if not m:
+                            del attrs[attr]
+                        elif m.group('content_type') not in self.allowed_content_types:
+                            del attrs[attr]
+
+            for attr in self.svg_attr_val_allows_ref:
+                if attr in attrs:
+                    attrs[attr] = re.sub(r'url\s*\(\s*[^#\s][^)]+?\)',
+                                         ' ',
+                                         unescape(attrs[attr]))
+            if (token["name"] in self.svg_allow_local_href and
+                (namespaces['xlink'], 'href') in attrs and re.search(r'^\s*[^#\s].*',
+                                                                     attrs[(namespaces['xlink'], 'href')])):
+                del attrs[(namespaces['xlink'], 'href')]
+            if (None, 'style') in attrs:
+                attrs[(None, 'style')] = self.sanitize_css(attrs[(None, 'style')])
+            token["data"] = attrs
+        return token
+
+    def disallowed_token(self, token):
+        token_type = token["type"]
+        if token_type == "EndTag":
+            token["data"] = "</%s>" % token["name"]
+        elif token["data"]:
+            assert token_type in ("StartTag", "EmptyTag")
+            attrs = []
+            for (ns, name), v in token["data"].items():
+                attrs.append(' %s="%s"' % (name if ns is None else "%s:%s" % (prefixes[ns], name), escape(v)))
+            token["data"] = "<%s%s>" % (token["name"], ''.join(attrs))
+        else:
+            token["data"] = "<%s>" % token["name"]
+        if token.get("selfClosing"):
+            token["data"] = token["data"][:-1] + "/>"
+
+        token["type"] = "Characters"
+
+        del token["name"]
+        return token
+
+    def sanitize_css(self, style):
+        # disallow urls
+        style = re.compile(r'url\s*\(\s*[^\s)]+?\s*\)\s*').sub(' ', style)
+
+        # gauntlet
+        if not re.match(r"""^([:,;#%.\sa-zA-Z0-9!]|\w-\w|'[\s\w]+'|"[\s\w]+"|\([\d,\s]+\))*$""", style):
+            return ''
+        if not re.match(r"^\s*([-\w]+\s*:[^:;]*(;\s*|$))*$", style):
+            return ''
+
+        clean = []
+        for prop, value in re.findall(r"([-\w]+)\s*:\s*([^:;]*)", style):
+            if not value:
+                continue
+            if prop.lower() in self.allowed_css_properties:
+                clean.append(prop + ': ' + value + ';')
+            elif prop.split('-')[0].lower() in ['background', 'border', 'margin',
+                                                'padding']:
+                for keyword in value.split():
+                    if keyword not in self.allowed_css_keywords and \
+                            not re.match(r"^(#[0-9a-fA-F]+|rgb\(\d+%?,\d*%?,?\d*%?\)?|\d{0,2}\.?\d{0,2}(cm|em|ex|in|mm|pc|pt|px|%|,|\))?)$", keyword):  # noqa
+                        break
+                else:
+                    clean.append(prop + ': ' + value + ';')
+            elif prop.lower() in self.allowed_svg_properties:
+                clean.append(prop + ': ' + value + ';')
+
+        return ' '.join(clean)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/whitespace.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/whitespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d12584b45995d35110f75af00193fdad0fa10f4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/filters/whitespace.py
@@ -0,0 +1,38 @@
+from __future__ import absolute_import, division, unicode_literals
+
+import re
+
+from . import base
+from ..constants import rcdataElements, spaceCharacters
+spaceCharacters = "".join(spaceCharacters)
+
+SPACES_REGEX = re.compile("[%s]+" % spaceCharacters)
+
+
+class Filter(base.Filter):
+    """Collapses whitespace except in pre, textarea, and script elements"""
+    spacePreserveElements = frozenset(["pre", "textarea"] + list(rcdataElements))
+
+    def __iter__(self):
+        preserve = 0
+        for token in base.Filter.__iter__(self):
+            type = token["type"]
+            if type == "StartTag" \
+                    and (preserve or token["name"] in self.spacePreserveElements):
+                preserve += 1
+
+            elif type == "EndTag" and preserve:
+                preserve -= 1
+
+            elif not preserve and type == "SpaceCharacters" and token["data"]:
+                # Test on token["data"] above to not introduce spaces where there were not
+                token["data"] = " "
+
+            elif not preserve and type == "Characters":
+                token["data"] = collapse_spaces(token["data"])
+
+            yield token
+
+
+def collapse_spaces(text):
+    return SPACES_REGEX.sub(' ', text)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bec2076f3f60e644cdd3265d8e113ca17149dfd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py
@@ -0,0 +1,154 @@
+"""A collection of modules for iterating through different kinds of
+tree, generating tokens identical to those produced by the tokenizer
+module.
+
+To create a tree walker for a new type of tree, you need to do
+implement a tree walker object (called TreeWalker by convention) that
+implements a 'serialize' method taking a tree as sole argument and
+returning an iterator generating tokens.
+"""
+
+from __future__ import absolute_import, division, unicode_literals
+
+from .. import constants
+from .._utils import default_etree
+
+__all__ = ["getTreeWalker", "pprint"]
+
+treeWalkerCache = {}
+
+
+def getTreeWalker(treeType, implementation=None, **kwargs):
+    """Get a TreeWalker class for various types of tree with built-in support
+
+    :arg str treeType: the name of the tree type required (case-insensitive).
+        Supported values are:
+
+        * "dom": The xml.dom.minidom DOM implementation
+        * "etree": A generic walker for tree implementations exposing an
+          elementtree-like interface (known to work with ElementTree,
+          cElementTree and lxml.etree).
+        * "lxml": Optimized walker for lxml.etree
+        * "genshi": a Genshi stream
+
+    :arg implementation: A module implementing the tree type e.g.
+        xml.etree.ElementTree or cElementTree (Currently applies to the "etree"
+        tree type only).
+
+    :arg kwargs: keyword arguments passed to the etree walker--for other
+        walkers, this has no effect
+
+    :returns: a TreeWalker class
+
+    """
+
+    treeType = treeType.lower()
+    if treeType not in treeWalkerCache:
+        if treeType == "dom":
+            from . import dom
+            treeWalkerCache[treeType] = dom.TreeWalker
+        elif treeType == "genshi":
+            from . import genshi
+            treeWalkerCache[treeType] = genshi.TreeWalker
+        elif treeType == "lxml":
+            from . import etree_lxml
+            treeWalkerCache[treeType] = etree_lxml.TreeWalker
+        elif treeType == "etree":
+            from . import etree
+            if implementation is None:
+                implementation = default_etree
+            # XXX: NEVER cache here, caching is done in the etree submodule
+            return etree.getETreeModule(implementation, **kwargs).TreeWalker
+    return treeWalkerCache.get(treeType)
+
+
+def concatenateCharacterTokens(tokens):
+    pendingCharacters = []
+    for token in tokens:
+        type = token["type"]
+        if type in ("Characters", "SpaceCharacters"):
+            pendingCharacters.append(token["data"])
+        else:
+            if pendingCharacters:
+                yield {"type": "Characters", "data": "".join(pendingCharacters)}
+                pendingCharacters = []
+            yield token
+    if pendingCharacters:
+        yield {"type": "Characters", "data": "".join(pendingCharacters)}
+
+
+def pprint(walker):
+    """Pretty printer for tree walkers
+
+    Takes a TreeWalker instance and pretty prints the output of walking the tree.
+
+    :arg walker: a TreeWalker instance
+
+    """
+    output = []
+    indent = 0
+    for token in concatenateCharacterTokens(walker):
+        type = token["type"]
+        if type in ("StartTag", "EmptyTag"):
+            # tag name
+            if token["namespace"] and token["namespace"] != constants.namespaces["html"]:
+                if token["namespace"] in constants.prefixes:
+                    ns = constants.prefixes[token["namespace"]]
+                else:
+                    ns = token["namespace"]
+                name = "%s %s" % (ns, token["name"])
+            else:
+                name = token["name"]
+            output.append("%s<%s>" % (" " * indent, name))
+            indent += 2
+            # attributes (sorted for consistent ordering)
+            attrs = token["data"]
+            for (namespace, localname), value in sorted(attrs.items()):
+                if namespace:
+                    if namespace in constants.prefixes:
+                        ns = constants.prefixes[namespace]
+                    else:
+                        ns = namespace
+                    name = "%s %s" % (ns, localname)
+                else:
+                    name = localname
+                output.append("%s%s=\"%s\"" % (" " * indent, name, value))
+            # self-closing
+            if type == "EmptyTag":
+                indent -= 2
+
+        elif type == "EndTag":
+            indent -= 2
+
+        elif type == "Comment":
+            output.append("%s<!-- %s -->" % (" " * indent, token["data"]))
+
+        elif type == "Doctype":
+            if token["name"]:
+                if token["publicId"]:
+                    output.append("""%s<!DOCTYPE %s "%s" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["publicId"],
+                                   token["systemId"] if token["systemId"] else ""))
+                elif token["systemId"]:
+                    output.append("""%s<!DOCTYPE %s "" "%s">""" %
+                                  (" " * indent,
+                                   token["name"],
+                                   token["systemId"]))
+                else:
+                    output.append("%s<!DOCTYPE %s>" % (" " * indent,
+                                                       token["name"]))
+            else:
+                output.append("%s<!DOCTYPE >" % (" " * indent,))
+
+        elif type == "Characters":
+            output.append("%s\"%s\"" % (" " * indent, token["data"]))
+
+        elif type == "SpaceCharacters":
+            assert False, "concatenateCharacterTokens should have got rid of all Space tokens"
+
+        else:
+            raise ValueError("Unknown token type, %s" % type)
+
+    return "\n".join(output)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree.py
new file mode 100644
index 0000000000000000000000000000000000000000..95fc0c170301532cf2b499cd1697fe1179ae80c5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree.py
@@ -0,0 +1,130 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from collections import OrderedDict
+import re
+
+from pip._vendor.six import string_types
+
+from . import base
+from .._utils import moduleFactoryFactory
+
+tag_regexp = re.compile("{([^}]*)}(.*)")
+
+
+def getETreeBuilder(ElementTreeImplementation):
+    ElementTree = ElementTreeImplementation
+    ElementTreeCommentType = ElementTree.Comment("asd").tag
+
+    class TreeWalker(base.NonRecursiveTreeWalker):  # pylint:disable=unused-variable
+        """Given the particular ElementTree representation, this implementation,
+        to avoid using recursion, returns "nodes" as tuples with the following
+        content:
+
+        1. The current element
+
+        2. The index of the element relative to its parent
+
+        3. A stack of ancestor elements
+
+        4. A flag "text", "tail" or None to indicate if the current node is a
+           text node; either the text or tail of the current element (1)
+        """
+        def getNodeDetails(self, node):
+            if isinstance(node, tuple):  # It might be the root Element
+                elt, _, _, flag = node
+                if flag in ("text", "tail"):
+                    return base.TEXT, getattr(elt, flag)
+                else:
+                    node = elt
+
+            if not(hasattr(node, "tag")):
+                node = node.getroot()
+
+            if node.tag in ("DOCUMENT_ROOT", "DOCUMENT_FRAGMENT"):
+                return (base.DOCUMENT,)
+
+            elif node.tag == "<!DOCTYPE>":
+                return (base.DOCTYPE, node.text,
+                        node.get("publicId"), node.get("systemId"))
+
+            elif node.tag == ElementTreeCommentType:
+                return base.COMMENT, node.text
+
+            else:
+                assert isinstance(node.tag, string_types), type(node.tag)
+                # This is assumed to be an ordinary element
+                match = tag_regexp.match(node.tag)
+                if match:
+                    namespace, tag = match.groups()
+                else:
+                    namespace = None
+                    tag = node.tag
+                attrs = OrderedDict()
+                for name, value in list(node.attrib.items()):
+                    match = tag_regexp.match(name)
+                    if match:
+                        attrs[(match.group(1), match.group(2))] = value
+                    else:
+                        attrs[(None, name)] = value
+                return (base.ELEMENT, namespace, tag,
+                        attrs, len(node) or node.text)
+
+        def getFirstChild(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                element, key, parents, flag = node, None, [], None
+
+            if flag in ("text", "tail"):
+                return None
+            else:
+                if element.text:
+                    return element, key, parents, "text"
+                elif len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+
+        def getNextSibling(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if len(element):
+                    parents.append(element)
+                    return element[0], 0, parents, None
+                else:
+                    return None
+            else:
+                if element.tail and flag != "tail":
+                    return element, key, parents, "tail"
+                elif key < len(parents[-1]) - 1:
+                    return parents[-1][key + 1], key + 1, parents, None
+                else:
+                    return None
+
+        def getParentNode(self, node):
+            if isinstance(node, tuple):
+                element, key, parents, flag = node
+            else:
+                return None
+
+            if flag == "text":
+                if not parents:
+                    return element
+                else:
+                    return element, key, parents, None
+            else:
+                parent = parents.pop()
+                if not parents:
+                    return parent
+                else:
+                    assert list(parents[-1]).count(parent) == 1
+                    return parent, list(parents[-1]).index(parent), parents, None
+
+    return locals()
+
+getETreeModule = moduleFactoryFactory(getETreeBuilder)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py
new file mode 100644
index 0000000000000000000000000000000000000000..e81ddf33b2eff3b278effd4602ef1511311ee4f6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py
@@ -0,0 +1,213 @@
+from __future__ import absolute_import, division, unicode_literals
+from pip._vendor.six import text_type
+
+from lxml import etree
+from ..treebuilders.etree import tag_regexp
+
+from . import base
+
+from .. import _ihatexml
+
+
+def ensure_str(s):
+    if s is None:
+        return None
+    elif isinstance(s, text_type):
+        return s
+    else:
+        return s.decode("ascii", "strict")
+
+
+class Root(object):
+    def __init__(self, et):
+        self.elementtree = et
+        self.children = []
+
+        try:
+            if et.docinfo.internalDTD:
+                self.children.append(Doctype(self,
+                                             ensure_str(et.docinfo.root_name),
+                                             ensure_str(et.docinfo.public_id),
+                                             ensure_str(et.docinfo.system_url)))
+        except AttributeError:
+            pass
+
+        try:
+            node = et.getroot()
+        except AttributeError:
+            node = et
+
+        while node.getprevious() is not None:
+            node = node.getprevious()
+        while node is not None:
+            self.children.append(node)
+            node = node.getnext()
+
+        self.text = None
+        self.tail = None
+
+    def __getitem__(self, key):
+        return self.children[key]
+
+    def getnext(self):
+        return None
+
+    def __len__(self):
+        return 1
+
+
+class Doctype(object):
+    def __init__(self, root_node, name, public_id, system_id):
+        self.root_node = root_node
+        self.name = name
+        self.public_id = public_id
+        self.system_id = system_id
+
+        self.text = None
+        self.tail = None
+
+    def getnext(self):
+        return self.root_node.children[1]
+
+
+class FragmentRoot(Root):
+    def __init__(self, children):
+        self.children = [FragmentWrapper(self, child) for child in children]
+        self.text = self.tail = None
+
+    def getnext(self):
+        return None
+
+
+class FragmentWrapper(object):
+    def __init__(self, fragment_root, obj):
+        self.root_node = fragment_root
+        self.obj = obj
+        if hasattr(self.obj, 'text'):
+            self.text = ensure_str(self.obj.text)
+        else:
+            self.text = None
+        if hasattr(self.obj, 'tail'):
+            self.tail = ensure_str(self.obj.tail)
+        else:
+            self.tail = None
+
+    def __getattr__(self, name):
+        return getattr(self.obj, name)
+
+    def getnext(self):
+        siblings = self.root_node.children
+        idx = siblings.index(self)
+        if idx < len(siblings) - 1:
+            return siblings[idx + 1]
+        else:
+            return None
+
+    def __getitem__(self, key):
+        return self.obj[key]
+
+    def __bool__(self):
+        return bool(self.obj)
+
+    def getparent(self):
+        return None
+
+    def __str__(self):
+        return str(self.obj)
+
+    def __unicode__(self):
+        return str(self.obj)
+
+    def __len__(self):
+        return len(self.obj)
+
+
+class TreeWalker(base.NonRecursiveTreeWalker):
+    def __init__(self, tree):
+        # pylint:disable=redefined-variable-type
+        if isinstance(tree, list):
+            self.fragmentChildren = set(tree)
+            tree = FragmentRoot(tree)
+        else:
+            self.fragmentChildren = set()
+            tree = Root(tree)
+        base.NonRecursiveTreeWalker.__init__(self, tree)
+        self.filter = _ihatexml.InfosetFilter()
+
+    def getNodeDetails(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            return base.TEXT, ensure_str(getattr(node, key))
+
+        elif isinstance(node, Root):
+            return (base.DOCUMENT,)
+
+        elif isinstance(node, Doctype):
+            return base.DOCTYPE, node.name, node.public_id, node.system_id
+
+        elif isinstance(node, FragmentWrapper) and not hasattr(node, "tag"):
+            return base.TEXT, ensure_str(node.obj)
+
+        elif node.tag == etree.Comment:
+            return base.COMMENT, ensure_str(node.text)
+
+        elif node.tag == etree.Entity:
+            return base.ENTITY, ensure_str(node.text)[1:-1]  # strip &;
+
+        else:
+            # This is assumed to be an ordinary element
+            match = tag_regexp.match(ensure_str(node.tag))
+            if match:
+                namespace, tag = match.groups()
+            else:
+                namespace = None
+                tag = ensure_str(node.tag)
+            attrs = {}
+            for name, value in list(node.attrib.items()):
+                name = ensure_str(name)
+                value = ensure_str(value)
+                match = tag_regexp.match(name)
+                if match:
+                    attrs[(match.group(1), match.group(2))] = value
+                else:
+                    attrs[(None, name)] = value
+            return (base.ELEMENT, namespace, self.filter.fromXmlName(tag),
+                    attrs, len(node) > 0 or node.text)
+
+    def getFirstChild(self, node):
+        assert not isinstance(node, tuple), "Text nodes have no children"
+
+        assert len(node) or node.text, "Node has no children"
+        if node.text:
+            return (node, "text")
+        else:
+            return node[0]
+
+    def getNextSibling(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                # XXX: we cannot use a "bool(node) and node[0] or None" construct here
+                # because node[0] might evaluate to False if it has no child element
+                if len(node):
+                    return node[0]
+                else:
+                    return None
+            else:  # tail
+                return node.getnext()
+
+        return (node, "tail") if node.tail else node.getnext()
+
+    def getParentNode(self, node):
+        if isinstance(node, tuple):  # Text node
+            node, key = node
+            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
+            if key == "text":
+                return node
+            # else: fallback to "normal" processing
+        elif node in self.fragmentChildren:
+            return None
+
+        return node.getparent()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py
new file mode 100644
index 0000000000000000000000000000000000000000..7483be27d4d24f845e56b6954ee63eec730c00aa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/genshi.py
@@ -0,0 +1,69 @@
+from __future__ import absolute_import, division, unicode_literals
+
+from genshi.core import QName
+from genshi.core import START, END, XML_NAMESPACE, DOCTYPE, TEXT
+from genshi.core import START_NS, END_NS, START_CDATA, END_CDATA, PI, COMMENT
+
+from . import base
+
+from ..constants import voidElements, namespaces
+
+
+class TreeWalker(base.TreeWalker):
+    def __iter__(self):
+        # Buffer the events so we can pass in the following one
+        previous = None
+        for event in self.tree:
+            if previous is not None:
+                for token in self.tokens(previous, event):
+                    yield token
+            previous = event
+
+        # Don't forget the final event!
+        if previous is not None:
+            for token in self.tokens(previous, None):
+                yield token
+
+    def tokens(self, event, next):
+        kind, data, _ = event
+        if kind == START:
+            tag, attribs = data
+            name = tag.localname
+            namespace = tag.namespace
+            converted_attribs = {}
+            for k, v in attribs:
+                if isinstance(k, QName):
+                    converted_attribs[(k.namespace, k.localname)] = v
+                else:
+                    converted_attribs[(None, k)] = v
+
+            if namespace == namespaces["html"] and name in voidElements:
+                for token in self.emptyTag(namespace, name, converted_attribs,
+                                           not next or next[0] != END or
+                                           next[1] != tag):
+                    yield token
+            else:
+                yield self.startTag(namespace, name, converted_attribs)
+
+        elif kind == END:
+            name = data.localname
+            namespace = data.namespace
+            if namespace != namespaces["html"] or name not in voidElements:
+                yield self.endTag(namespace, name)
+
+        elif kind == COMMENT:
+            yield self.comment(data)
+
+        elif kind == TEXT:
+            for token in self.text(data):
+                yield token
+
+        elif kind == DOCTYPE:
+            yield self.doctype(*data)
+
+        elif kind in (XML_NAMESPACE, DOCTYPE, START_NS, END_NS,
+                      START_CDATA, END_CDATA, PI):
+            pass
+
+        else:
+            yield self.unknown(kind)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__about__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__about__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7481c9e298370f034602faff6c045cb1fecf504b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__about__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "19.0"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD or Apache License, Version 2.0"
+__copyright__ = "Copyright 2014-2019 %s" % __author__
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0cf67df5245be16a020ca048832e180f7ce8661
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/__init__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+from .__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..25da473c196855ad59a6d2d785ef1ddef49795be
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_compat.py
@@ -0,0 +1,31 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+    string_types = (str,)
+else:
+    string_types = (basestring,)
+
+
+def with_metaclass(meta, *bases):
+    """
+    Create a base class with a metaclass.
+    """
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+
+    return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_structures.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_structures.py
new file mode 100644
index 0000000000000000000000000000000000000000..68dcca634d8e3f0081bad2f9ae5e653a2942db68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/_structures.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+
+class Infinity(object):
+    def __repr__(self):
+        return "Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return False
+
+    def __le__(self, other):
+        return False
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return True
+
+    def __ge__(self, other):
+        return True
+
+    def __neg__(self):
+        return NegativeInfinity
+
+
+Infinity = Infinity()
+
+
+class NegativeInfinity(object):
+    def __repr__(self):
+        return "-Infinity"
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __lt__(self, other):
+        return True
+
+    def __le__(self, other):
+        return True
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__)
+
+    def __ne__(self, other):
+        return not isinstance(other, self.__class__)
+
+    def __gt__(self, other):
+        return False
+
+    def __ge__(self, other):
+        return False
+
+    def __neg__(self):
+        return Infinity
+
+
+NegativeInfinity = NegativeInfinity()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..95157a1f78c26829ffbe1bd2463f7735b636d16f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/version.py
@@ -0,0 +1,420 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import collections
+import itertools
+import re
+
+from ._structures import Infinity
+
+
+__all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
+
+
+_Version = collections.namedtuple(
+    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
+)
+
+
+def parse(version):
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion(object):
+    def __hash__(self):
+        return hash(self._key)
+
+    def __lt__(self, other):
+        return self._compare(other, lambda s, o: s < o)
+
+    def __le__(self, other):
+        return self._compare(other, lambda s, o: s <= o)
+
+    def __eq__(self, other):
+        return self._compare(other, lambda s, o: s == o)
+
+    def __ge__(self, other):
+        return self._compare(other, lambda s, o: s >= o)
+
+    def __gt__(self, other):
+        return self._compare(other, lambda s, o: s > o)
+
+    def __ne__(self, other):
+        return self._compare(other, lambda s, o: s != o)
+
+    def _compare(self, other, method):
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return method(self._key, other._key)
+
+
+class LegacyVersion(_BaseVersion):
+    def __init__(self, version):
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+    def __str__(self):
+        return self._version
+
+    def __repr__(self):
+        return "<LegacyVersion({0})>".format(repr(str(self)))
+
+    @property
+    def public(self):
+        return self._version
+
+    @property
+    def base_version(self):
+        return self._version
+
+    @property
+    def epoch(self):
+        return -1
+
+    @property
+    def release(self):
+        return None
+
+    @property
+    def pre(self):
+        return None
+
+    @property
+    def post(self):
+        return None
+
+    @property
+    def dev(self):
+        return None
+
+    @property
+    def local(self):
+        return None
+
+    @property
+    def is_prerelease(self):
+        return False
+
+    @property
+    def is_postrelease(self):
+        return False
+
+    @property
+    def is_devrelease(self):
+        return False
+
+
+_legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
+
+_legacy_version_replacement_map = {
+    "pre": "c",
+    "preview": "c",
+    "-": "final-",
+    "rc": "c",
+    "dev": "@",
+}
+
+
+def _parse_version_parts(s):
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version):
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts = []
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+    parts = tuple(parts)
+
+    return epoch, parts
+
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
+            post=_parse_letter_version(
+                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
+            ),
+            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        return "<Version({0})>".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        # Pre-release
+        if self.pre is not None:
+            parts.append("".join(str(x) for x in self.pre))
+
+        # Post-release
+        if self.post is not None:
+            parts.append(".post{0}".format(self.post))
+
+        # Development release
+        if self.dev is not None:
+            parts.append(".dev{0}".format(self.dev))
+
+        # Local version segment
+        if self.local is not None:
+            parts.append("+{0}".format(self.local))
+
+        return "".join(parts)
+
+    @property
+    def epoch(self):
+        return self._version.epoch
+
+    @property
+    def release(self):
+        return self._version.release
+
+    @property
+    def pre(self):
+        return self._version.pre
+
+    @property
+    def post(self):
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self):
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self):
+        if self._version.local:
+            return ".".join(str(x) for x in self._version.local)
+        else:
+            return None
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self.epoch != 0:
+            parts.append("{0}!".format(self.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self.release))
+
+        return "".join(parts)
+
+    @property
+    def is_prerelease(self):
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self):
+        return self.post is not None
+
+    @property
+    def is_devrelease(self):
+        return self.dev is not None
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_separators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    release = tuple(
+        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        pre = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        local = tuple((i, "") if isinstance(i, int) else (-Infinity, i) for i in local)
+
+    return epoch, release, pre, post, dev, local
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c1a098f78cedaa99049c71c96c778d8a84ac3a1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/__init__.py
@@ -0,0 +1,4 @@
+"""Wrappers to build Python packages using PEP 517 hooks
+"""
+
+__version__ = '0.5.0'
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/_in_process.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/_in_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6524b660a89853ac078bb853bedaf61d5eadb77
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/_in_process.py
@@ -0,0 +1,207 @@
+"""This is invoked in a subprocess to call the build backend hooks.
+
+It expects:
+- Command line args: hook_name, control_dir
+- Environment variable: PEP517_BUILD_BACKEND=entry.point:spec
+- control_dir/input.json:
+  - {"kwargs": {...}}
+
+Results:
+- control_dir/output.json
+  - {"return_val": ...}
+"""
+from glob import glob
+from importlib import import_module
+import os
+from os.path import join as pjoin
+import re
+import shutil
+import sys
+
+# This is run as a script, not a module, so it can't do a relative import
+import compat
+
+
+class BackendUnavailable(Exception):
+    """Raised if we cannot import the backend"""
+
+
+def _build_backend():
+    """Find and load the build backend"""
+    ep = os.environ['PEP517_BUILD_BACKEND']
+    mod_path, _, obj_path = ep.partition(':')
+    try:
+        obj = import_module(mod_path)
+    except ImportError:
+        raise BackendUnavailable
+    if obj_path:
+        for path_part in obj_path.split('.'):
+            obj = getattr(obj, path_part)
+    return obj
+
+
+def get_requires_for_build_wheel(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_wheel
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings):
+    """Invoke optional prepare_metadata_for_build_wheel
+
+    Implements a fallback by building a wheel if the hook isn't defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.prepare_metadata_for_build_wheel
+    except AttributeError:
+        return _get_wheel_metadata_from_wheel(backend, metadata_directory,
+                                              config_settings)
+    else:
+        return hook(metadata_directory, config_settings)
+
+
+WHEEL_BUILT_MARKER = 'PEP517_ALREADY_BUILT_WHEEL'
+
+
+def _dist_info_files(whl_zip):
+    """Identify the .dist-info folder inside a wheel ZipFile."""
+    res = []
+    for path in whl_zip.namelist():
+        m = re.match(r'[^/\\]+-[^/\\]+\.dist-info/', path)
+        if m:
+            res.append(path)
+    if res:
+        return res
+    raise Exception("No .dist-info folder found in wheel")
+
+
+def _get_wheel_metadata_from_wheel(
+        backend, metadata_directory, config_settings):
+    """Build a wheel and extract the metadata from it.
+
+    Fallback for when the build backend does not
+    define the 'get_wheel_metadata' hook.
+    """
+    from zipfile import ZipFile
+    whl_basename = backend.build_wheel(metadata_directory, config_settings)
+    with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), 'wb'):
+        pass  # Touch marker file
+
+    whl_file = os.path.join(metadata_directory, whl_basename)
+    with ZipFile(whl_file) as zipf:
+        dist_info = _dist_info_files(zipf)
+        zipf.extractall(path=metadata_directory, members=dist_info)
+    return dist_info[0].split('/')[0]
+
+
+def _find_already_built_wheel(metadata_directory):
+    """Check for a wheel already built during the get_wheel_metadata hook.
+    """
+    if not metadata_directory:
+        return None
+    metadata_parent = os.path.dirname(metadata_directory)
+    if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)):
+        return None
+
+    whl_files = glob(os.path.join(metadata_parent, '*.whl'))
+    if not whl_files:
+        print('Found wheel built marker, but no .whl files')
+        return None
+    if len(whl_files) > 1:
+        print('Found multiple .whl files; unspecified behaviour. '
+              'Will call build_wheel.')
+        return None
+
+    # Exactly one .whl file
+    return whl_files[0]
+
+
+def build_wheel(wheel_directory, config_settings, metadata_directory=None):
+    """Invoke the mandatory build_wheel hook.
+
+    If a wheel was already built in the
+    prepare_metadata_for_build_wheel fallback, this
+    will copy it rather than rebuilding the wheel.
+    """
+    prebuilt_whl = _find_already_built_wheel(metadata_directory)
+    if prebuilt_whl:
+        shutil.copy2(prebuilt_whl, wheel_directory)
+        return os.path.basename(prebuilt_whl)
+
+    return _build_backend().build_wheel(wheel_directory, config_settings,
+                                        metadata_directory)
+
+
+def get_requires_for_build_sdist(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_sdist
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+
+class _DummyException(Exception):
+    """Nothing should ever raise this exception"""
+
+
+class GotUnsupportedOperation(Exception):
+    """For internal use when backend raises UnsupportedOperation"""
+
+
+def build_sdist(sdist_directory, config_settings):
+    """Invoke the mandatory build_sdist hook."""
+    backend = _build_backend()
+    try:
+        return backend.build_sdist(sdist_directory, config_settings)
+    except getattr(backend, 'UnsupportedOperation', _DummyException):
+        raise GotUnsupportedOperation
+
+
+HOOK_NAMES = {
+    'get_requires_for_build_wheel',
+    'prepare_metadata_for_build_wheel',
+    'build_wheel',
+    'get_requires_for_build_sdist',
+    'build_sdist',
+}
+
+
+def main():
+    if len(sys.argv) < 3:
+        sys.exit("Needs args: hook_name, control_dir")
+    hook_name = sys.argv[1]
+    control_dir = sys.argv[2]
+    if hook_name not in HOOK_NAMES:
+        sys.exit("Unknown hook: %s" % hook_name)
+    hook = globals()[hook_name]
+
+    hook_input = compat.read_json(pjoin(control_dir, 'input.json'))
+
+    json_out = {'unsupported': False, 'return_val': None}
+    try:
+        json_out['return_val'] = hook(**hook_input['kwargs'])
+    except BackendUnavailable:
+        json_out['no_backend'] = True
+    except GotUnsupportedOperation:
+        json_out['unsupported'] = True
+
+    compat.write_json(json_out, pjoin(control_dir, 'output.json'), indent=2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/build.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac6c9495caa9385386a3b3c84b32e15c5a1dba28
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/build.py
@@ -0,0 +1,108 @@
+"""Build a project using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+import contextlib
+from pip._vendor import pytoml
+import shutil
+import errno
+import tempfile
+
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+
+@contextlib.contextmanager
+def tempdir():
+    td = tempfile.mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+
+def _do_build(hooks, env, dist, dest):
+    get_requires_name = 'get_requires_for_build_{dist}'.format(**locals())
+    get_requires = getattr(hooks, get_requires_name)
+    reqs = get_requires({})
+    log.info('Got build requires: %s', reqs)
+
+    env.pip_install(reqs)
+    log.info('Installed dynamic build dependencies')
+
+    with tempdir() as td:
+        log.info('Trying to build %s in %s', dist, td)
+        build_name = 'build_{dist}'.format(**locals())
+        build = getattr(hooks, build_name)
+        filename = build(td, {})
+        source = os.path.join(td, filename)
+        shutil.move(source, os.path.join(dest, os.path.basename(filename)))
+
+
+def mkdir_p(*args, **kwargs):
+    """Like `mkdir`, but does not raise an exception if the
+    directory already exists.
+    """
+    try:
+        return os.mkdir(*args, **kwargs)
+    except OSError as exc:
+        if exc.errno != errno.EEXIST:
+            raise
+
+
+def build(source_dir, dist, dest=None):
+    pyproject = os.path.join(source_dir, 'pyproject.toml')
+    dest = os.path.join(source_dir, dest or 'dist')
+    mkdir_p(dest)
+
+    with open(pyproject) as f:
+        pyproject_data = pytoml.load(f)
+    # Ensure the mandatory data can be loaded
+    buildsys = pyproject_data['build-system']
+    requires = buildsys['requires']
+    backend = buildsys['build-backend']
+
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        _do_build(hooks, env, dist, dest)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    'source_dir',
+    help="A directory containing pyproject.toml",
+)
+parser.add_argument(
+    '--binary', '-b',
+    action='store_true',
+    default=False,
+)
+parser.add_argument(
+    '--source', '-s',
+    action='store_true',
+    default=False,
+)
+parser.add_argument(
+    '--out-dir', '-o',
+    help="Destination in which to save the builds relative to source dir",
+)
+
+
+def main(args):
+    # determine which dists to build
+    dists = list(filter(None, (
+        'sdist' if args.source or not args.binary else None,
+        'wheel' if args.binary or not args.source else None,
+    )))
+
+    for dist in dists:
+        build(args.source_dir, dist, args.out_dir)
+
+
+if __name__ == '__main__':
+    main(parser.parse_args())
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/check.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/check.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4cdc6bec979fc28acba9d2f7c41923548fe253f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/check.py
@@ -0,0 +1,202 @@
+"""Check a project and backend by attempting to build using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+from os.path import isfile, join as pjoin
+from pip._vendor.pytoml import TomlError, load as toml_load
+import shutil
+from subprocess import CalledProcessError
+import sys
+import tarfile
+from tempfile import mkdtemp
+import zipfile
+
+from .colorlog import enable_colourful_output
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+
+def check_build_sdist(hooks, build_sys_requires):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_sdist({})
+            log.info('Got build requires: %s', reqs)
+        except Exception:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build sdist in %s', td)
+        try:
+            try:
+                filename = hooks.build_sdist(td, {})
+                log.info('build_sdist returned %r', filename)
+            except Exception:
+                log.info('Failure in build_sdist', exc_info=True)
+                return False
+
+            if not filename.endswith('.tar.gz'):
+                log.error(
+                    "Filename %s doesn't have .tar.gz extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if tarfile.is_tarfile(path):
+                log.info("Output file is a tar file")
+            else:
+                log.error("Output file is not a tar file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+
+def check_build_wheel(hooks, build_sys_requires):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_wheel({})
+            log.info('Got build requires: %s', reqs)
+        except Exception:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build wheel in %s', td)
+        try:
+            try:
+                filename = hooks.build_wheel(td, {})
+                log.info('build_wheel returned %r', filename)
+            except Exception:
+                log.info('Failure in build_wheel', exc_info=True)
+                return False
+
+            if not filename.endswith('.whl'):
+                log.error("Filename %s doesn't have .whl extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if zipfile.is_zipfile(path):
+                log.info("Output file is a zip file")
+            else:
+                log.error("Output file is not a zip file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+
+def check(source_dir):
+    pyproject = pjoin(source_dir, 'pyproject.toml')
+    if isfile(pyproject):
+        log.info('Found pyproject.toml')
+    else:
+        log.error('Missing pyproject.toml')
+        return False
+
+    try:
+        with open(pyproject) as f:
+            pyproject_data = toml_load(f)
+        # Ensure the mandatory data can be loaded
+        buildsys = pyproject_data['build-system']
+        requires = buildsys['requires']
+        backend = buildsys['build-backend']
+        log.info('Loaded pyproject.toml')
+    except (TomlError, KeyError):
+        log.error("Invalid pyproject.toml", exc_info=True)
+        return False
+
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    sdist_ok = check_build_sdist(hooks, requires)
+    wheel_ok = check_build_wheel(hooks, requires)
+
+    if not sdist_ok:
+        log.warning('Sdist checks failed; scroll up to see')
+    if not wheel_ok:
+        log.warning('Wheel checks failed')
+
+    return sdist_ok
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        'source_dir',
+        help="A directory containing pyproject.toml")
+    args = ap.parse_args(argv)
+
+    enable_colourful_output()
+
+    ok = check(args.source_dir)
+
+    if ok:
+        print(ansi('Checks passed', 'green'))
+    else:
+        print(ansi('Checks failed', 'red'))
+        sys.exit(1)
+
+
+ansi_codes = {
+    'reset': '\x1b[0m',
+    'bold': '\x1b[1m',
+    'red': '\x1b[31m',
+    'green': '\x1b[32m',
+}
+
+
+def ansi(s, attr):
+    if os.name != 'nt' and sys.stdout.isatty():
+        return ansi_codes[attr] + str(s) + ansi_codes['reset']
+    else:
+        return str(s)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/colorlog.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/colorlog.py
new file mode 100644
index 0000000000000000000000000000000000000000..69c8a59d3d4e038450aa37ec5b801914b817e675
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/colorlog.py
@@ -0,0 +1,115 @@
+"""Nicer log formatting with colours.
+
+Code copied from Tornado, Apache licensed.
+"""
+# Copyright 2012 Facebook
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import logging
+import sys
+
+try:
+    import curses
+except ImportError:
+    curses = None
+
+
+def _stderr_supports_color():
+    color = False
+    if curses and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
+        try:
+            curses.setupterm()
+            if curses.tigetnum("colors") > 0:
+                color = True
+        except Exception:
+            pass
+    return color
+
+
+class LogFormatter(logging.Formatter):
+    """Log formatter with colour support
+    """
+    DEFAULT_COLORS = {
+        logging.INFO: 2,  # Green
+        logging.WARNING: 3,  # Yellow
+        logging.ERROR: 1,  # Red
+        logging.CRITICAL: 1,
+    }
+
+    def __init__(self, color=True, datefmt=None):
+        r"""
+        :arg bool color: Enables color support.
+        :arg string fmt: Log message format.
+        It will be applied to the attributes dict of log records. The
+        text between ``%(color)s`` and ``%(end_color)s`` will be colored
+        depending on the level if color support is on.
+        :arg dict colors: color mappings from logging level to terminal color
+        code
+        :arg string datefmt: Datetime format.
+        Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
+        .. versionchanged:: 3.2
+        Added ``fmt`` and ``datefmt`` arguments.
+        """
+        logging.Formatter.__init__(self, datefmt=datefmt)
+        self._colors = {}
+        if color and _stderr_supports_color():
+            # The curses module has some str/bytes confusion in
+            # python3. Until version 3.2.3, most methods return
+            # bytes, but only accept strings. In addition, we want to
+            # output these strings with the logging module, which
+            # works with unicode strings. The explicit calls to
+            # unicode() below are harmless in python2 but will do the
+            # right conversion in python 3.
+            fg_color = (curses.tigetstr("setaf") or
+                        curses.tigetstr("setf") or "")
+            if (3, 0) < sys.version_info < (3, 2, 3):
+                fg_color = str(fg_color, "ascii")
+
+            for levelno, code in self.DEFAULT_COLORS.items():
+                self._colors[levelno] = str(
+                    curses.tparm(fg_color, code), "ascii")
+            self._normal = str(curses.tigetstr("sgr0"), "ascii")
+
+            scr = curses.initscr()
+            self.termwidth = scr.getmaxyx()[1]
+            curses.endwin()
+        else:
+            self._normal = ''
+            # Default width is usually 80, but too wide is
+            # worse than too narrow
+            self.termwidth = 70
+
+    def formatMessage(self, record):
+        mlen = len(record.message)
+        right_text = '{initial}-{name}'.format(initial=record.levelname[0],
+                                               name=record.name)
+        if mlen + len(right_text) < self.termwidth:
+            space = ' ' * (self.termwidth - (mlen + len(right_text)))
+        else:
+            space = '  '
+
+        if record.levelno in self._colors:
+            start_color = self._colors[record.levelno]
+            end_color = self._normal
+        else:
+            start_color = end_color = ''
+
+        return record.message + space + start_color + right_text + end_color
+
+
+def enable_colourful_output(level=logging.INFO):
+    handler = logging.StreamHandler()
+    handler.setFormatter(LogFormatter())
+    logging.root.addHandler(handler)
+    logging.root.setLevel(level)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..01c66fc7e41fa1a2ac2afaddecb5b17d6cadfc93
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/compat.py
@@ -0,0 +1,23 @@
+"""Handle reading and writing JSON in UTF-8, on Python 3 and 2."""
+import json
+import sys
+
+if sys.version_info[0] >= 3:
+    # Python 3
+    def write_json(obj, path, **kwargs):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(obj, f, **kwargs)
+
+    def read_json(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+else:
+    # Python 2
+    def write_json(obj, path, **kwargs):
+        with open(path, 'wb') as f:
+            json.dump(obj, f, encoding='utf-8', **kwargs)
+
+    def read_json(path):
+        with open(path, 'rb') as f:
+            return json.load(f)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/envbuild.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/envbuild.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7ac5f46f7c16d645d4573ab84dbceba5c33b920
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/envbuild.py
@@ -0,0 +1,158 @@
+"""Build wheels/sdists by installing build deps to a temporary environment.
+"""
+
+import os
+import logging
+from pip._vendor import pytoml
+import shutil
+from subprocess import check_call
+import sys
+from sysconfig import get_paths
+from tempfile import mkdtemp
+
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+
+def _load_pyproject(source_dir):
+    with open(os.path.join(source_dir, 'pyproject.toml')) as f:
+        pyproject_data = pytoml.load(f)
+    buildsys = pyproject_data['build-system']
+    return buildsys['requires'], buildsys['build-backend']
+
+
+class BuildEnvironment(object):
+    """Context manager to install build deps in a simple temporary environment
+
+    Based on code I wrote for pip, which is MIT licensed.
+    """
+    # Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
+    #
+    # 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.
+
+    path = None
+
+    def __init__(self, cleanup=True):
+        self._cleanup = cleanup
+
+    def __enter__(self):
+        self.path = mkdtemp(prefix='pep517-build-env-')
+        log.info('Temporary build environment: %s', self.path)
+
+        self.save_path = os.environ.get('PATH', None)
+        self.save_pythonpath = os.environ.get('PYTHONPATH', None)
+
+        install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix'
+        install_dirs = get_paths(install_scheme, vars={
+            'base': self.path,
+            'platbase': self.path,
+        })
+
+        scripts = install_dirs['scripts']
+        if self.save_path:
+            os.environ['PATH'] = scripts + os.pathsep + self.save_path
+        else:
+            os.environ['PATH'] = scripts + os.pathsep + os.defpath
+
+        if install_dirs['purelib'] == install_dirs['platlib']:
+            lib_dirs = install_dirs['purelib']
+        else:
+            lib_dirs = install_dirs['purelib'] + os.pathsep + \
+                install_dirs['platlib']
+        if self.save_pythonpath:
+            os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \
+                self.save_pythonpath
+        else:
+            os.environ['PYTHONPATH'] = lib_dirs
+
+        return self
+
+    def pip_install(self, reqs):
+        """Install dependencies into this env by calling pip in a subprocess"""
+        if not reqs:
+            return
+        log.info('Calling pip to install %s', reqs)
+        check_call([
+            sys.executable, '-m', 'pip', 'install', '--ignore-installed',
+            '--prefix', self.path] + list(reqs))
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        needs_cleanup = (
+            self._cleanup and
+            self.path is not None and
+            os.path.isdir(self.path)
+        )
+        if needs_cleanup:
+            shutil.rmtree(self.path)
+
+        if self.save_path is None:
+            os.environ.pop('PATH', None)
+        else:
+            os.environ['PATH'] = self.save_path
+
+        if self.save_pythonpath is None:
+            os.environ.pop('PYTHONPATH', None)
+        else:
+            os.environ['PYTHONPATH'] = self.save_pythonpath
+
+
+def build_wheel(source_dir, wheel_dir, config_settings=None):
+    """Build a wheel from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str wheel_dir: Target directory to create wheel in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_wheel(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_wheel(wheel_dir, config_settings)
+
+
+def build_sdist(source_dir, sdist_dir, config_settings=None):
+    """Build an sdist from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str sdist_dir: Target directory to place sdist in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_sdist(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_sdist(sdist_dir, config_settings)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/wrappers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..b14b899150a07d9bf1d9551a739a52f2795ffbd2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pep517/wrappers.py
@@ -0,0 +1,163 @@
+from contextlib import contextmanager
+import os
+from os.path import dirname, abspath, join as pjoin
+import shutil
+from subprocess import check_call
+import sys
+from tempfile import mkdtemp
+
+from . import compat
+
+_in_proc_script = pjoin(dirname(abspath(__file__)), '_in_process.py')
+
+
+@contextmanager
+def tempdir():
+    td = mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+
+class BackendUnavailable(Exception):
+    """Will be raised if the backend cannot be imported in the hook process."""
+
+
+class UnsupportedOperation(Exception):
+    """May be raised by build_sdist if the backend indicates that it can't."""
+
+
+def default_subprocess_runner(cmd, cwd=None, extra_environ=None):
+    """The default method of calling the wrapper subprocess."""
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+
+    check_call(cmd, cwd=cwd, env=env)
+
+
+class Pep517HookCaller(object):
+    """A wrapper around a source directory to be built with a PEP 517 backend.
+
+    source_dir : The path to the source directory, containing pyproject.toml.
+    backend : The build backend spec, as per PEP 517, from pyproject.toml.
+    """
+    def __init__(self, source_dir, build_backend):
+        self.source_dir = abspath(source_dir)
+        self.build_backend = build_backend
+        self._subprocess_runner = default_subprocess_runner
+
+    # TODO: Is this over-engineered? Maybe frontends only need to
+    #       set this when creating the wrapper, not on every call.
+    @contextmanager
+    def subprocess_runner(self, runner):
+        prev = self._subprocess_runner
+        self._subprocess_runner = runner
+        yield
+        self._subprocess_runner = prev
+
+    def get_requires_for_build_wheel(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["wheel >= 0.25", "setuptools"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_wheel', {
+            'config_settings': config_settings
+        })
+
+    def prepare_metadata_for_build_wheel(
+            self, metadata_directory, config_settings=None):
+        """Prepare a *.dist-info folder with metadata for this project.
+
+        Returns the name of the newly created folder.
+
+        If the build backend defines a hook with this name, it will be called
+        in a subprocess. If not, the backend will be asked to build a wheel,
+        and the dist-info extracted from that.
+        """
+        return self._call_hook('prepare_metadata_for_build_wheel', {
+            'metadata_directory': abspath(metadata_directory),
+            'config_settings': config_settings,
+        })
+
+    def build_wheel(
+            self, wheel_directory, config_settings=None,
+            metadata_directory=None):
+        """Build a wheel from this project.
+
+        Returns the name of the newly created file.
+
+        In general, this will call the 'build_wheel' hook in the backend.
+        However, if that was previously called by
+        'prepare_metadata_for_build_wheel', and the same metadata_directory is
+        used, the previously built wheel will be copied to wheel_directory.
+        """
+        if metadata_directory is not None:
+            metadata_directory = abspath(metadata_directory)
+        return self._call_hook('build_wheel', {
+            'wheel_directory': abspath(wheel_directory),
+            'config_settings': config_settings,
+            'metadata_directory': metadata_directory,
+        })
+
+    def get_requires_for_build_sdist(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["setuptools >= 26"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_sdist', {
+            'config_settings': config_settings
+        })
+
+    def build_sdist(self, sdist_directory, config_settings=None):
+        """Build an sdist from this project.
+
+        Returns the name of the newly created file.
+
+        This calls the 'build_sdist' backend hook in a subprocess.
+        """
+        return self._call_hook('build_sdist', {
+            'sdist_directory': abspath(sdist_directory),
+            'config_settings': config_settings,
+        })
+
+    def _call_hook(self, hook_name, kwargs):
+        # On Python 2, pytoml returns Unicode values (which is correct) but the
+        # environment passed to check_call needs to contain string values. We
+        # convert here by encoding using ASCII (the backend can only contain
+        # letters, digits and _, . and : characters, and will be used as a
+        # Python identifier, so non-ASCII content is wrong on Python 2 in
+        # any case).
+        if sys.version_info[0] == 2:
+            build_backend = self.build_backend.encode('ASCII')
+        else:
+            build_backend = self.build_backend
+
+        with tempdir() as td:
+            compat.write_json({'kwargs': kwargs}, pjoin(td, 'input.json'),
+                              indent=2)
+
+            # Run the hook in a subprocess
+            self._subprocess_runner(
+                [sys.executable, _in_proc_script, hook_name, td],
+                cwd=self.source_dir,
+                extra_environ={'PEP517_BUILD_BACKEND': build_backend}
+            )
+
+            data = compat.read_json(pjoin(td, 'output.json'))
+            if data.get('unsupported'):
+                raise UnsupportedOperation
+            if data.get('no_backend'):
+                raise BackendUnavailable
+            return data['return_val']
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdd40de414991a0ac8b2819d386b1f372601375e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/__init__.py
@@ -0,0 +1,3286 @@
+# coding: utf-8
+"""
+Package resource API
+--------------------
+
+A resource is a logical file contained within a package, or a logical
+subdirectory thereof.  The package resource API expects resource names
+to have their path parts separated with ``/``, *not* whatever the local
+path separator is.  Do not use os.path operations to manipulate resource
+names being passed into the API.
+
+The package resource API is designed to work with normal filesystem packages,
+.egg files, and unpacked .egg files.  It can also work in a limited way with
+.zip files and with custom PEP 302 loaders that support the ``get_data()``
+method.
+"""
+
+from __future__ import absolute_import
+
+import sys
+import os
+import io
+import time
+import re
+import types
+import zipfile
+import zipimport
+import warnings
+import stat
+import functools
+import pkgutil
+import operator
+import platform
+import collections
+import plistlib
+import email.parser
+import errno
+import tempfile
+import textwrap
+import itertools
+import inspect
+import ntpath
+import posixpath
+from pkgutil import get_importer
+
+try:
+    import _imp
+except ImportError:
+    # Python 3.2 compatibility
+    import imp as _imp
+
+try:
+    FileExistsError
+except NameError:
+    FileExistsError = OSError
+
+from pip._vendor import six
+from pip._vendor.six.moves import urllib, map, filter
+
+# capture these to bypass sandboxing
+from os import utime
+try:
+    from os import mkdir, rename, unlink
+    WRITE_SUPPORT = True
+except ImportError:
+    # no write support, probably under GAE
+    WRITE_SUPPORT = False
+
+from os import open as os_open
+from os.path import isdir, split
+
+try:
+    import importlib.machinery as importlib_machinery
+    # access attribute to force import under delayed import mechanisms.
+    importlib_machinery.__name__
+except ImportError:
+    importlib_machinery = None
+
+from . import py31compat
+from pip._vendor import appdirs
+from pip._vendor import packaging
+__import__('pip._vendor.packaging.version')
+__import__('pip._vendor.packaging.specifiers')
+__import__('pip._vendor.packaging.requirements')
+__import__('pip._vendor.packaging.markers')
+
+
+__metaclass__ = type
+
+
+if (3, 0) < sys.version_info < (3, 4):
+    raise RuntimeError("Python 3.4 or later is required")
+
+if six.PY2:
+    # Those builtin exceptions are only defined in Python 3
+    PermissionError = None
+    NotADirectoryError = None
+
+# declare some globals that will be defined later to
+# satisfy the linters.
+require = None
+working_set = None
+add_activation_listener = None
+resources_stream = None
+cleanup_resources = None
+resource_dir = None
+resource_stream = None
+set_extraction_path = None
+resource_isdir = None
+resource_string = None
+iter_entry_points = None
+resource_listdir = None
+resource_filename = None
+resource_exists = None
+_distribution_finders = None
+_namespace_handlers = None
+_namespace_packages = None
+
+
+class PEP440Warning(RuntimeWarning):
+    """
+    Used when there is an issue with a version or specifier not complying with
+    PEP 440.
+    """
+
+
+def parse_version(v):
+    try:
+        return packaging.version.Version(v)
+    except packaging.version.InvalidVersion:
+        return packaging.version.LegacyVersion(v)
+
+
+_state_vars = {}
+
+
+def _declare_state(vartype, **kw):
+    globals().update(kw)
+    _state_vars.update(dict.fromkeys(kw, vartype))
+
+
+def __getstate__():
+    state = {}
+    g = globals()
+    for k, v in _state_vars.items():
+        state[k] = g['_sget_' + v](g[k])
+    return state
+
+
+def __setstate__(state):
+    g = globals()
+    for k, v in state.items():
+        g['_sset_' + _state_vars[k]](k, g[k], v)
+    return state
+
+
+def _sget_dict(val):
+    return val.copy()
+
+
+def _sset_dict(key, ob, state):
+    ob.clear()
+    ob.update(state)
+
+
+def _sget_object(val):
+    return val.__getstate__()
+
+
+def _sset_object(key, ob, state):
+    ob.__setstate__(state)
+
+
+_sget_none = _sset_none = lambda *args: None
+
+
+def get_supported_platform():
+    """Return this platform's maximum compatible version.
+
+    distutils.util.get_platform() normally reports the minimum version
+    of Mac OS X that would be required to *use* extensions produced by
+    distutils.  But what we want when checking compatibility is to know the
+    version of Mac OS X that we are *running*.  To allow usage of packages that
+    explicitly require a newer version of Mac OS X, we must also know the
+    current version of the OS.
+
+    If this condition occurs for any other platform with a version in its
+    platform strings, this function should be extended accordingly.
+    """
+    plat = get_build_platform()
+    m = macosVersionString.match(plat)
+    if m is not None and sys.platform == "darwin":
+        try:
+            plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
+        except ValueError:
+            # not Mac OS X
+            pass
+    return plat
+
+
+__all__ = [
+    # Basic resource access and distribution/entry point discovery
+    'require', 'run_script', 'get_provider', 'get_distribution',
+    'load_entry_point', 'get_entry_map', 'get_entry_info',
+    'iter_entry_points',
+    'resource_string', 'resource_stream', 'resource_filename',
+    'resource_listdir', 'resource_exists', 'resource_isdir',
+
+    # Environmental control
+    'declare_namespace', 'working_set', 'add_activation_listener',
+    'find_distributions', 'set_extraction_path', 'cleanup_resources',
+    'get_default_cache',
+
+    # Primary implementation classes
+    'Environment', 'WorkingSet', 'ResourceManager',
+    'Distribution', 'Requirement', 'EntryPoint',
+
+    # Exceptions
+    'ResolutionError', 'VersionConflict', 'DistributionNotFound',
+    'UnknownExtra', 'ExtractionError',
+
+    # Warnings
+    'PEP440Warning',
+
+    # Parsing functions and string utilities
+    'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
+    'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
+    'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
+
+    # filesystem utilities
+    'ensure_directory', 'normalize_path',
+
+    # Distribution "precedence" constants
+    'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
+
+    # "Provider" interfaces, implementations, and registration/lookup APIs
+    'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
+    'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
+    'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
+    'register_finder', 'register_namespace_handler', 'register_loader_type',
+    'fixup_namespace_packages', 'get_importer',
+
+    # Warnings
+    'PkgResourcesDeprecationWarning',
+
+    # Deprecated/backward compatibility only
+    'run_main', 'AvailableDistributions',
+]
+
+
+class ResolutionError(Exception):
+    """Abstract base for dependency resolution errors"""
+
+    def __repr__(self):
+        return self.__class__.__name__ + repr(self.args)
+
+
+class VersionConflict(ResolutionError):
+    """
+    An already-installed version conflicts with the requested version.
+
+    Should be initialized with the installed Distribution and the requested
+    Requirement.
+    """
+
+    _template = "{self.dist} is installed but {self.req} is required"
+
+    @property
+    def dist(self):
+        return self.args[0]
+
+    @property
+    def req(self):
+        return self.args[1]
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def with_context(self, required_by):
+        """
+        If required_by is non-empty, return a version of self that is a
+        ContextualVersionConflict.
+        """
+        if not required_by:
+            return self
+        args = self.args + (required_by,)
+        return ContextualVersionConflict(*args)
+
+
+class ContextualVersionConflict(VersionConflict):
+    """
+    A VersionConflict that accepts a third parameter, the set of the
+    requirements that required the installed Distribution.
+    """
+
+    _template = VersionConflict._template + ' by {self.required_by}'
+
+    @property
+    def required_by(self):
+        return self.args[2]
+
+
+class DistributionNotFound(ResolutionError):
+    """A requested distribution was not found"""
+
+    _template = ("The '{self.req}' distribution was not found "
+                 "and is required by {self.requirers_str}")
+
+    @property
+    def req(self):
+        return self.args[0]
+
+    @property
+    def requirers(self):
+        return self.args[1]
+
+    @property
+    def requirers_str(self):
+        if not self.requirers:
+            return 'the application'
+        return ', '.join(self.requirers)
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def __str__(self):
+        return self.report()
+
+
+class UnknownExtra(ResolutionError):
+    """Distribution doesn't have an "extra feature" of the given name"""
+
+
+_provider_factories = {}
+
+PY_MAJOR = sys.version[:3]
+EGG_DIST = 3
+BINARY_DIST = 2
+SOURCE_DIST = 1
+CHECKOUT_DIST = 0
+DEVELOP_DIST = -1
+
+
+def register_loader_type(loader_type, provider_factory):
+    """Register `provider_factory` to make providers for `loader_type`
+
+    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
+    and `provider_factory` is a function that, passed a *module* object,
+    returns an ``IResourceProvider`` for that module.
+    """
+    _provider_factories[loader_type] = provider_factory
+
+
+def get_provider(moduleOrReq):
+    """Return an IResourceProvider for the named module or requirement"""
+    if isinstance(moduleOrReq, Requirement):
+        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
+    try:
+        module = sys.modules[moduleOrReq]
+    except KeyError:
+        __import__(moduleOrReq)
+        module = sys.modules[moduleOrReq]
+    loader = getattr(module, '__loader__', None)
+    return _find_adapter(_provider_factories, loader)(module)
+
+
+def _macosx_vers(_cache=[]):
+    if not _cache:
+        version = platform.mac_ver()[0]
+        # fallback for MacPorts
+        if version == '':
+            plist = '/System/Library/CoreServices/SystemVersion.plist'
+            if os.path.exists(plist):
+                if hasattr(plistlib, 'readPlist'):
+                    plist_content = plistlib.readPlist(plist)
+                    if 'ProductVersion' in plist_content:
+                        version = plist_content['ProductVersion']
+
+        _cache.append(version.split('.'))
+    return _cache[0]
+
+
+def _macosx_arch(machine):
+    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
+
+
+def get_build_platform():
+    """Return this platform's string for platform-specific distributions
+
+    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
+    needs some hacks for Linux and Mac OS X.
+    """
+    from sysconfig import get_platform
+
+    plat = get_platform()
+    if sys.platform == "darwin" and not plat.startswith('macosx-'):
+        try:
+            version = _macosx_vers()
+            machine = os.uname()[4].replace(" ", "_")
+            return "macosx-%d.%d-%s" % (
+                int(version[0]), int(version[1]),
+                _macosx_arch(machine),
+            )
+        except ValueError:
+            # if someone is running a non-Mac darwin system, this will fall
+            # through to the default implementation
+            pass
+    return plat
+
+
+macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
+darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
+# XXX backward compat
+get_platform = get_build_platform
+
+
+def compatible_platforms(provided, required):
+    """Can code for the `provided` platform run on the `required` platform?
+
+    Returns true if either platform is ``None``, or the platforms are equal.
+
+    XXX Needs compatibility checks for Linux and other unixy OSes.
+    """
+    if provided is None or required is None or provided == required:
+        # easy case
+        return True
+
+    # Mac OS X special cases
+    reqMac = macosVersionString.match(required)
+    if reqMac:
+        provMac = macosVersionString.match(provided)
+
+        # is this a Mac package?
+        if not provMac:
+            # this is backwards compatibility for packages built before
+            # setuptools 0.6. All packages built after this point will
+            # use the new macosx designation.
+            provDarwin = darwinVersionString.match(provided)
+            if provDarwin:
+                dversion = int(provDarwin.group(1))
+                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
+                if dversion == 7 and macosversion >= "10.3" or \
+                        dversion == 8 and macosversion >= "10.4":
+                    return True
+            # egg isn't macosx or legacy darwin
+            return False
+
+        # are they the same major version and machine type?
+        if provMac.group(1) != reqMac.group(1) or \
+                provMac.group(3) != reqMac.group(3):
+            return False
+
+        # is the required OS major update >= the provided one?
+        if int(provMac.group(2)) > int(reqMac.group(2)):
+            return False
+
+        return True
+
+    # XXX Linux and other platforms' special cases should go here
+    return False
+
+
+def run_script(dist_spec, script_name):
+    """Locate distribution `dist_spec` and run its `script_name` script"""
+    ns = sys._getframe(1).f_globals
+    name = ns['__name__']
+    ns.clear()
+    ns['__name__'] = name
+    require(dist_spec)[0].run_script(script_name, ns)
+
+
+# backward compatibility
+run_main = run_script
+
+
+def get_distribution(dist):
+    """Return a current distribution object for a Requirement or string"""
+    if isinstance(dist, six.string_types):
+        dist = Requirement.parse(dist)
+    if isinstance(dist, Requirement):
+        dist = get_provider(dist)
+    if not isinstance(dist, Distribution):
+        raise TypeError("Expected string, Requirement, or Distribution", dist)
+    return dist
+
+
+def load_entry_point(dist, group, name):
+    """Return `name` entry point of `group` for `dist` or raise ImportError"""
+    return get_distribution(dist).load_entry_point(group, name)
+
+
+def get_entry_map(dist, group=None):
+    """Return the entry point map for `group`, or the full entry map"""
+    return get_distribution(dist).get_entry_map(group)
+
+
+def get_entry_info(dist, group, name):
+    """Return the EntryPoint object for `group`+`name`, or ``None``"""
+    return get_distribution(dist).get_entry_info(group, name)
+
+
+class IMetadataProvider:
+    def has_metadata(name):
+        """Does the package's distribution contain the named metadata?"""
+
+    def get_metadata(name):
+        """The named metadata resource as a string"""
+
+    def get_metadata_lines(name):
+        """Yield named metadata resource as list of non-blank non-comment lines
+
+       Leading and trailing whitespace is stripped from each line, and lines
+       with ``#`` as the first non-blank character are omitted."""
+
+    def metadata_isdir(name):
+        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
+
+    def metadata_listdir(name):
+        """List of metadata names in the directory (like ``os.listdir()``)"""
+
+    def run_script(script_name, namespace):
+        """Execute the named script in the supplied namespace dictionary"""
+
+
+class IResourceProvider(IMetadataProvider):
+    """An object that provides access to package resources"""
+
+    def get_resource_filename(manager, resource_name):
+        """Return a true filesystem path for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_stream(manager, resource_name):
+        """Return a readable file-like object for `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def get_resource_string(manager, resource_name):
+        """Return a string containing the contents of `resource_name`
+
+        `manager` must be an ``IResourceManager``"""
+
+    def has_resource(resource_name):
+        """Does the package contain the named resource?"""
+
+    def resource_isdir(resource_name):
+        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
+
+    def resource_listdir(resource_name):
+        """List of resource names in the directory (like ``os.listdir()``)"""
+
+
+class WorkingSet:
+    """A collection of active distributions on sys.path (or a similar list)"""
+
+    def __init__(self, entries=None):
+        """Create working set from list of path entries (default=sys.path)"""
+        self.entries = []
+        self.entry_keys = {}
+        self.by_key = {}
+        self.callbacks = []
+
+        if entries is None:
+            entries = sys.path
+
+        for entry in entries:
+            self.add_entry(entry)
+
+    @classmethod
+    def _build_master(cls):
+        """
+        Prepare the master working set.
+        """
+        ws = cls()
+        try:
+            from __main__ import __requires__
+        except ImportError:
+            # The main program does not list any requirements
+            return ws
+
+        # ensure the requirements are met
+        try:
+            ws.require(__requires__)
+        except VersionConflict:
+            return cls._build_from_requirements(__requires__)
+
+        return ws
+
+    @classmethod
+    def _build_from_requirements(cls, req_spec):
+        """
+        Build a working set from a requirement spec. Rewrites sys.path.
+        """
+        # try it without defaults already on sys.path
+        # by starting with an empty path
+        ws = cls([])
+        reqs = parse_requirements(req_spec)
+        dists = ws.resolve(reqs, Environment())
+        for dist in dists:
+            ws.add(dist)
+
+        # add any missing entries from sys.path
+        for entry in sys.path:
+            if entry not in ws.entries:
+                ws.add_entry(entry)
+
+        # then copy back to sys.path
+        sys.path[:] = ws.entries
+        return ws
+
+    def add_entry(self, entry):
+        """Add a path item to ``.entries``, finding any distributions on it
+
+        ``find_distributions(entry, True)`` is used to find distributions
+        corresponding to the path entry, and they are added.  `entry` is
+        always appended to ``.entries``, even if it is already present.
+        (This is because ``sys.path`` can contain the same value more than
+        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
+        equal ``sys.path``.)
+        """
+        self.entry_keys.setdefault(entry, [])
+        self.entries.append(entry)
+        for dist in find_distributions(entry, True):
+            self.add(dist, entry, False)
+
+    def __contains__(self, dist):
+        """True if `dist` is the active distribution for its project"""
+        return self.by_key.get(dist.key) == dist
+
+    def find(self, req):
+        """Find a distribution matching requirement `req`
+
+        If there is an active distribution for the requested project, this
+        returns it as long as it meets the version requirement specified by
+        `req`.  But, if there is an active distribution for the project and it
+        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
+        If there is no active distribution for the requested project, ``None``
+        is returned.
+        """
+        dist = self.by_key.get(req.key)
+        if dist is not None and dist not in req:
+            # XXX add more info
+            raise VersionConflict(dist, req)
+        return dist
+
+    def iter_entry_points(self, group, name=None):
+        """Yield entry point objects from `group` matching `name`
+
+        If `name` is None, yields all entry points in `group` from all
+        distributions in the working set, otherwise only ones matching
+        both `group` and `name` are yielded (in distribution order).
+        """
+        return (
+            entry
+            for dist in self
+            for entry in dist.get_entry_map(group).values()
+            if name is None or name == entry.name
+        )
+
+    def run_script(self, requires, script_name):
+        """Locate distribution for `requires` and run `script_name` script"""
+        ns = sys._getframe(1).f_globals
+        name = ns['__name__']
+        ns.clear()
+        ns['__name__'] = name
+        self.require(requires)[0].run_script(script_name, ns)
+
+    def __iter__(self):
+        """Yield distributions for non-duplicate projects in the working set
+
+        The yield order is the order in which the items' path entries were
+        added to the working set.
+        """
+        seen = {}
+        for item in self.entries:
+            if item not in self.entry_keys:
+                # workaround a cache issue
+                continue
+
+            for key in self.entry_keys[item]:
+                if key not in seen:
+                    seen[key] = 1
+                    yield self.by_key[key]
+
+    def add(self, dist, entry=None, insert=True, replace=False):
+        """Add `dist` to working set, associated with `entry`
+
+        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
+        On exit from this routine, `entry` is added to the end of the working
+        set's ``.entries`` (if it wasn't already present).
+
+        `dist` is only added to the working set if it's for a project that
+        doesn't already have a distribution in the set, unless `replace=True`.
+        If it's added, any callbacks registered with the ``subscribe()`` method
+        will be called.
+        """
+        if insert:
+            dist.insert_on(self.entries, entry, replace=replace)
+
+        if entry is None:
+            entry = dist.location
+        keys = self.entry_keys.setdefault(entry, [])
+        keys2 = self.entry_keys.setdefault(dist.location, [])
+        if not replace and dist.key in self.by_key:
+            # ignore hidden distros
+            return
+
+        self.by_key[dist.key] = dist
+        if dist.key not in keys:
+            keys.append(dist.key)
+        if dist.key not in keys2:
+            keys2.append(dist.key)
+        self._added_new(dist)
+
+    def resolve(self, requirements, env=None, installer=None,
+                replace_conflicting=False, extras=None):
+        """List all distributions needed to (recursively) meet `requirements`
+
+        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
+        if supplied, should be an ``Environment`` instance.  If
+        not supplied, it defaults to all distributions available within any
+        entry or distribution in the working set.  `installer`, if supplied,
+        will be invoked with each requirement that cannot be met by an
+        already-installed distribution; it should return a ``Distribution`` or
+        ``None``.
+
+        Unless `replace_conflicting=True`, raises a VersionConflict exception
+        if
+        any requirements are found on the path that have the correct name but
+        the wrong version.  Otherwise, if an `installer` is supplied it will be
+        invoked to obtain the correct version of the requirement and activate
+        it.
+
+        `extras` is a list of the extras to be used with these requirements.
+        This is important because extra requirements may look like `my_req;
+        extra = "my_extra"`, which would otherwise be interpreted as a purely
+        optional requirement.  Instead, we want to be able to assert that these
+        requirements are truly required.
+        """
+
+        # set up the stack
+        requirements = list(requirements)[::-1]
+        # set of processed requirements
+        processed = {}
+        # key -> dist
+        best = {}
+        to_activate = []
+
+        req_extras = _ReqExtras()
+
+        # Mapping of requirement to set of distributions that required it;
+        # useful for reporting info about conflicts.
+        required_by = collections.defaultdict(set)
+
+        while requirements:
+            # process dependencies breadth-first
+            req = requirements.pop(0)
+            if req in processed:
+                # Ignore cyclic or redundant dependencies
+                continue
+
+            if not req_extras.markers_pass(req, extras):
+                continue
+
+            dist = best.get(req.key)
+            if dist is None:
+                # Find the best distribution and add it to the map
+                dist = self.by_key.get(req.key)
+                if dist is None or (dist not in req and replace_conflicting):
+                    ws = self
+                    if env is None:
+                        if dist is None:
+                            env = Environment(self.entries)
+                        else:
+                            # Use an empty environment and workingset to avoid
+                            # any further conflicts with the conflicting
+                            # distribution
+                            env = Environment([])
+                            ws = WorkingSet([])
+                    dist = best[req.key] = env.best_match(
+                        req, ws, installer,
+                        replace_conflicting=replace_conflicting
+                    )
+                    if dist is None:
+                        requirers = required_by.get(req, None)
+                        raise DistributionNotFound(req, requirers)
+                to_activate.append(dist)
+            if dist not in req:
+                # Oops, the "best" so far conflicts with a dependency
+                dependent_req = required_by[req]
+                raise VersionConflict(dist, req).with_context(dependent_req)
+
+            # push the new requirements onto the stack
+            new_requirements = dist.requires(req.extras)[::-1]
+            requirements.extend(new_requirements)
+
+            # Register the new requirements needed by req
+            for new_requirement in new_requirements:
+                required_by[new_requirement].add(req.project_name)
+                req_extras[new_requirement] = req.extras
+
+            processed[req] = True
+
+        # return list of distros to activate
+        return to_activate
+
+    def find_plugins(
+            self, plugin_env, full_env=None, installer=None, fallback=True):
+        """Find all activatable distributions in `plugin_env`
+
+        Example usage::
+
+            distributions, errors = working_set.find_plugins(
+                Environment(plugin_dirlist)
+            )
+            # add plugins+libs to sys.path
+            map(working_set.add, distributions)
+            # display errors
+            print('Could not load', errors)
+
+        The `plugin_env` should be an ``Environment`` instance that contains
+        only distributions that are in the project's "plugin directory" or
+        directories. The `full_env`, if supplied, should be an ``Environment``
+        contains all currently-available distributions.  If `full_env` is not
+        supplied, one is created automatically from the ``WorkingSet`` this
+        method is called on, which will typically mean that every directory on
+        ``sys.path`` will be scanned for distributions.
+
+        `installer` is a standard installer callback as used by the
+        ``resolve()`` method. The `fallback` flag indicates whether we should
+        attempt to resolve older versions of a plugin if the newest version
+        cannot be resolved.
+
+        This method returns a 2-tuple: (`distributions`, `error_info`), where
+        `distributions` is a list of the distributions found in `plugin_env`
+        that were loadable, along with any other distributions that are needed
+        to resolve their dependencies.  `error_info` is a dictionary mapping
+        unloadable plugin distributions to an exception instance describing the
+        error that occurred. Usually this will be a ``DistributionNotFound`` or
+        ``VersionConflict`` instance.
+        """
+
+        plugin_projects = list(plugin_env)
+        # scan project names in alphabetic order
+        plugin_projects.sort()
+
+        error_info = {}
+        distributions = {}
+
+        if full_env is None:
+            env = Environment(self.entries)
+            env += plugin_env
+        else:
+            env = full_env + plugin_env
+
+        shadow_set = self.__class__([])
+        # put all our entries in shadow_set
+        list(map(shadow_set.add, self))
+
+        for project_name in plugin_projects:
+
+            for dist in plugin_env[project_name]:
+
+                req = [dist.as_requirement()]
+
+                try:
+                    resolvees = shadow_set.resolve(req, env, installer)
+
+                except ResolutionError as v:
+                    # save error info
+                    error_info[dist] = v
+                    if fallback:
+                        # try the next older version of project
+                        continue
+                    else:
+                        # give up on this project, keep going
+                        break
+
+                else:
+                    list(map(shadow_set.add, resolvees))
+                    distributions.update(dict.fromkeys(resolvees))
+
+                    # success, no need to try any more versions of this project
+                    break
+
+        distributions = list(distributions)
+        distributions.sort()
+
+        return distributions, error_info
+
+    def require(self, *requirements):
+        """Ensure that distributions matching `requirements` are activated
+
+        `requirements` must be a string or a (possibly-nested) sequence
+        thereof, specifying the distributions and versions required.  The
+        return value is a sequence of the distributions that needed to be
+        activated to fulfill the requirements; all relevant distributions are
+        included, even if they were already activated in this working set.
+        """
+        needed = self.resolve(parse_requirements(requirements))
+
+        for dist in needed:
+            self.add(dist)
+
+        return needed
+
+    def subscribe(self, callback, existing=True):
+        """Invoke `callback` for all distributions
+
+        If `existing=True` (default),
+        call on all existing ones, as well.
+        """
+        if callback in self.callbacks:
+            return
+        self.callbacks.append(callback)
+        if not existing:
+            return
+        for dist in self:
+            callback(dist)
+
+    def _added_new(self, dist):
+        for callback in self.callbacks:
+            callback(dist)
+
+    def __getstate__(self):
+        return (
+            self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
+            self.callbacks[:]
+        )
+
+    def __setstate__(self, e_k_b_c):
+        entries, keys, by_key, callbacks = e_k_b_c
+        self.entries = entries[:]
+        self.entry_keys = keys.copy()
+        self.by_key = by_key.copy()
+        self.callbacks = callbacks[:]
+
+
+class _ReqExtras(dict):
+    """
+    Map each requirement to the extras that demanded it.
+    """
+
+    def markers_pass(self, req, extras=None):
+        """
+        Evaluate markers for req against each extra that
+        demanded it.
+
+        Return False if the req has a marker and fails
+        evaluation. Otherwise, return True.
+        """
+        extra_evals = (
+            req.marker.evaluate({'extra': extra})
+            for extra in self.get(req, ()) + (extras or (None,))
+        )
+        return not req.marker or any(extra_evals)
+
+
+class Environment:
+    """Searchable snapshot of distributions on a search path"""
+
+    def __init__(
+            self, search_path=None, platform=get_supported_platform(),
+            python=PY_MAJOR):
+        """Snapshot distributions available on a search path
+
+        Any distributions found on `search_path` are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.
+
+        `platform` is an optional string specifying the name of the platform
+        that platform-specific distributions must be compatible with.  If
+        unspecified, it defaults to the current platform.  `python` is an
+        optional string naming the desired version of Python (e.g. ``'3.6'``);
+        it defaults to the current version.
+
+        You may explicitly set `platform` (and/or `python`) to ``None`` if you
+        wish to map *all* distributions, not just those compatible with the
+        running platform or Python version.
+        """
+        self._distmap = {}
+        self.platform = platform
+        self.python = python
+        self.scan(search_path)
+
+    def can_add(self, dist):
+        """Is distribution `dist` acceptable for this environment?
+
+        The distribution must match the platform and python version
+        requirements specified when this environment was created, or False
+        is returned.
+        """
+        py_compat = (
+            self.python is None
+            or dist.py_version is None
+            or dist.py_version == self.python
+        )
+        return py_compat and compatible_platforms(dist.platform, self.platform)
+
+    def remove(self, dist):
+        """Remove `dist` from the environment"""
+        self._distmap[dist.key].remove(dist)
+
+    def scan(self, search_path=None):
+        """Scan `search_path` for distributions usable in this environment
+
+        Any distributions found are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.  Only distributions conforming to
+        the platform/python version defined at initialization are added.
+        """
+        if search_path is None:
+            search_path = sys.path
+
+        for item in search_path:
+            for dist in find_distributions(item):
+                self.add(dist)
+
+    def __getitem__(self, project_name):
+        """Return a newest-to-oldest list of distributions for `project_name`
+
+        Uses case-insensitive `project_name` comparison, assuming all the
+        project's distributions use their project's name converted to all
+        lowercase as their key.
+
+        """
+        distribution_key = project_name.lower()
+        return self._distmap.get(distribution_key, [])
+
+    def add(self, dist):
+        """Add `dist` if we ``can_add()`` it and it has not already been added
+        """
+        if self.can_add(dist) and dist.has_version():
+            dists = self._distmap.setdefault(dist.key, [])
+            if dist not in dists:
+                dists.append(dist)
+                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
+
+    def best_match(
+            self, req, working_set, installer=None, replace_conflicting=False):
+        """Find distribution best matching `req` and usable on `working_set`
+
+        This calls the ``find(req)`` method of the `working_set` to see if a
+        suitable distribution is already active.  (This may raise
+        ``VersionConflict`` if an unsuitable version of the project is already
+        active in the specified `working_set`.)  If a suitable distribution
+        isn't active, this method returns the newest distribution in the
+        environment that meets the ``Requirement`` in `req`.  If no suitable
+        distribution is found, and `installer` is supplied, then the result of
+        calling the environment's ``obtain(req, installer)`` method will be
+        returned.
+        """
+        try:
+            dist = working_set.find(req)
+        except VersionConflict:
+            if not replace_conflicting:
+                raise
+            dist = None
+        if dist is not None:
+            return dist
+        for dist in self[req.key]:
+            if dist in req:
+                return dist
+        # try to download/install
+        return self.obtain(req, installer)
+
+    def obtain(self, requirement, installer=None):
+        """Obtain a distribution matching `requirement` (e.g. via download)
+
+        Obtain a distro that matches requirement (e.g. via download).  In the
+        base ``Environment`` class, this routine just returns
+        ``installer(requirement)``, unless `installer` is None, in which case
+        None is returned instead.  This method is a hook that allows subclasses
+        to attempt other ways of obtaining a distribution before falling back
+        to the `installer` argument."""
+        if installer is not None:
+            return installer(requirement)
+
+    def __iter__(self):
+        """Yield the unique project names of the available distributions"""
+        for key in self._distmap.keys():
+            if self[key]:
+                yield key
+
+    def __iadd__(self, other):
+        """In-place addition of a distribution or environment"""
+        if isinstance(other, Distribution):
+            self.add(other)
+        elif isinstance(other, Environment):
+            for project in other:
+                for dist in other[project]:
+                    self.add(dist)
+        else:
+            raise TypeError("Can't add %r to environment" % (other,))
+        return self
+
+    def __add__(self, other):
+        """Add an environment or distribution to an environment"""
+        new = self.__class__([], platform=None, python=None)
+        for env in self, other:
+            new += env
+        return new
+
+
+# XXX backward compatibility
+AvailableDistributions = Environment
+
+
+class ExtractionError(RuntimeError):
+    """An error occurred extracting a resource
+
+    The following attributes are available from instances of this exception:
+
+    manager
+        The resource manager that raised this exception
+
+    cache_path
+        The base directory for resource extraction
+
+    original_error
+        The exception instance that caused extraction to fail
+    """
+
+
+class ResourceManager:
+    """Manage resource extraction and packages"""
+    extraction_path = None
+
+    def __init__(self):
+        self.cached_files = {}
+
+    def resource_exists(self, package_or_requirement, resource_name):
+        """Does the named resource exist?"""
+        return get_provider(package_or_requirement).has_resource(resource_name)
+
+    def resource_isdir(self, package_or_requirement, resource_name):
+        """Is the named resource an existing directory?"""
+        return get_provider(package_or_requirement).resource_isdir(
+            resource_name
+        )
+
+    def resource_filename(self, package_or_requirement, resource_name):
+        """Return a true filesystem path for specified resource"""
+        return get_provider(package_or_requirement).get_resource_filename(
+            self, resource_name
+        )
+
+    def resource_stream(self, package_or_requirement, resource_name):
+        """Return a readable file-like object for specified resource"""
+        return get_provider(package_or_requirement).get_resource_stream(
+            self, resource_name
+        )
+
+    def resource_string(self, package_or_requirement, resource_name):
+        """Return specified resource as a string"""
+        return get_provider(package_or_requirement).get_resource_string(
+            self, resource_name
+        )
+
+    def resource_listdir(self, package_or_requirement, resource_name):
+        """List the contents of the named resource directory"""
+        return get_provider(package_or_requirement).resource_listdir(
+            resource_name
+        )
+
+    def extraction_error(self):
+        """Give an error message for problems extracting file(s)"""
+
+        old_exc = sys.exc_info()[1]
+        cache_path = self.extraction_path or get_default_cache()
+
+        tmpl = textwrap.dedent("""
+            Can't extract file(s) to egg cache
+
+            The following error occurred while trying to extract file(s)
+            to the Python egg cache:
+
+              {old_exc}
+
+            The Python egg cache directory is currently set to:
+
+              {cache_path}
+
+            Perhaps your account does not have write access to this directory?
+            You can change the cache directory by setting the PYTHON_EGG_CACHE
+            environment variable to point to an accessible directory.
+            """).lstrip()
+        err = ExtractionError(tmpl.format(**locals()))
+        err.manager = self
+        err.cache_path = cache_path
+        err.original_error = old_exc
+        raise err
+
+    def get_cache_path(self, archive_name, names=()):
+        """Return absolute location in cache for `archive_name` and `names`
+
+        The parent directory of the resulting path will be created if it does
+        not already exist.  `archive_name` should be the base filename of the
+        enclosing egg (which may not be the name of the enclosing zipfile!),
+        including its ".egg" extension.  `names`, if provided, should be a
+        sequence of path name parts "under" the egg's extraction location.
+
+        This method should only be called by resource providers that need to
+        obtain an extraction location, and only for names they intend to
+        extract, as it tracks the generated names for possible cleanup later.
+        """
+        extract_path = self.extraction_path or get_default_cache()
+        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
+        try:
+            _bypass_ensure_directory(target_path)
+        except Exception:
+            self.extraction_error()
+
+        self._warn_unsafe_extraction_path(extract_path)
+
+        self.cached_files[target_path] = 1
+        return target_path
+
+    @staticmethod
+    def _warn_unsafe_extraction_path(path):
+        """
+        If the default extraction path is overridden and set to an insecure
+        location, such as /tmp, it opens up an opportunity for an attacker to
+        replace an extracted file with an unauthorized payload. Warn the user
+        if a known insecure location is used.
+
+        See Distribute #375 for more details.
+        """
+        if os.name == 'nt' and not path.startswith(os.environ['windir']):
+            # On Windows, permissions are generally restrictive by default
+            #  and temp directories are not writable by other users, so
+            #  bypass the warning.
+            return
+        mode = os.stat(path).st_mode
+        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
+            msg = (
+                "%s is writable by group/others and vulnerable to attack "
+                "when "
+                "used with get_resource_filename. Consider a more secure "
+                "location (set with .set_extraction_path or the "
+                "PYTHON_EGG_CACHE environment variable)." % path
+            )
+            warnings.warn(msg, UserWarning)
+
+    def postprocess(self, tempname, filename):
+        """Perform any platform-specific postprocessing of `tempname`
+
+        This is where Mac header rewrites should be done; other platforms don't
+        have anything special they should do.
+
+        Resource providers should call this method ONLY after successfully
+        extracting a compressed resource.  They must NOT call it on resources
+        that are already in the filesystem.
+
+        `tempname` is the current (temporary) name of the file, and `filename`
+        is the name it will be renamed to by the caller after this routine
+        returns.
+        """
+
+        if os.name == 'posix':
+            # Make the resource executable
+            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
+            os.chmod(tempname, mode)
+
+    def set_extraction_path(self, path):
+        """Set the base path where resources will be extracted to, if needed.
+
+        If you do not call this routine before any extractions take place, the
+        path defaults to the return value of ``get_default_cache()``.  (Which
+        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
+        platform-specific fallbacks.  See that routine's documentation for more
+        details.)
+
+        Resources are extracted to subdirectories of this path based upon
+        information given by the ``IResourceProvider``.  You may set this to a
+        temporary directory, but then you must call ``cleanup_resources()`` to
+        delete the extracted files when done.  There is no guarantee that
+        ``cleanup_resources()`` will be able to remove all extracted files.
+
+        (Note: you may not change the extraction path for a given resource
+        manager once resources have been extracted, unless you first call
+        ``cleanup_resources()``.)
+        """
+        if self.cached_files:
+            raise ValueError(
+                "Can't change extraction path, files already extracted"
+            )
+
+        self.extraction_path = path
+
+    def cleanup_resources(self, force=False):
+        """
+        Delete all extracted resource files and directories, returning a list
+        of the file and directory names that could not be successfully removed.
+        This function does not have any concurrency protection, so it should
+        generally only be called when the extraction path is a temporary
+        directory exclusive to a single process.  This method is not
+        automatically called; you must call it explicitly or register it as an
+        ``atexit`` function if you wish to ensure cleanup of a temporary
+        directory used for extractions.
+        """
+        # XXX
+
+
+def get_default_cache():
+    """
+    Return the ``PYTHON_EGG_CACHE`` environment variable
+    or a platform-relevant user cache dir for an app
+    named "Python-Eggs".
+    """
+    return (
+        os.environ.get('PYTHON_EGG_CACHE')
+        or appdirs.user_cache_dir(appname='Python-Eggs')
+    )
+
+
+def safe_name(name):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version):
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(packaging.version.Version(version))
+    except packaging.version.InvalidVersion:
+        version = version.replace(' ', '.')
+        return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def safe_extra(extra):
+    """Convert an arbitrary string to a standard 'extra' name
+
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
+
+
+def to_filename(name):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-', '_')
+
+
+def invalid_marker(text):
+    """
+    Validate text as a PEP 508 environment marker; return an exception
+    if invalid or False otherwise.
+    """
+    try:
+        evaluate_marker(text)
+    except SyntaxError as e:
+        e.filename = None
+        e.lineno = None
+        return e
+    return False
+
+
+def evaluate_marker(text, extra=None):
+    """
+    Evaluate a PEP 508 environment marker.
+    Return a boolean indicating the marker result in this environment.
+    Raise SyntaxError if marker is invalid.
+
+    This implementation uses the 'pyparsing' module.
+    """
+    try:
+        marker = packaging.markers.Marker(text)
+        return marker.evaluate()
+    except packaging.markers.InvalidMarker as e:
+        raise SyntaxError(e)
+
+
+class NullProvider:
+    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
+
+    egg_name = None
+    egg_info = None
+    loader = None
+
+    def __init__(self, module):
+        self.loader = getattr(module, '__loader__', None)
+        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
+
+    def get_resource_filename(self, manager, resource_name):
+        return self._fn(self.module_path, resource_name)
+
+    def get_resource_stream(self, manager, resource_name):
+        return io.BytesIO(self.get_resource_string(manager, resource_name))
+
+    def get_resource_string(self, manager, resource_name):
+        return self._get(self._fn(self.module_path, resource_name))
+
+    def has_resource(self, resource_name):
+        return self._has(self._fn(self.module_path, resource_name))
+
+    def _get_metadata_path(self, name):
+        return self._fn(self.egg_info, name)
+
+    def has_metadata(self, name):
+        if not self.egg_info:
+            return self.egg_info
+
+        path = self._get_metadata_path(name)
+        return self._has(path)
+
+    def get_metadata(self, name):
+        if not self.egg_info:
+            return ""
+        value = self._get(self._fn(self.egg_info, name))
+        return value.decode('utf-8') if six.PY3 else value
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+    def resource_isdir(self, resource_name):
+        return self._isdir(self._fn(self.module_path, resource_name))
+
+    def metadata_isdir(self, name):
+        return self.egg_info and self._isdir(self._fn(self.egg_info, name))
+
+    def resource_listdir(self, resource_name):
+        return self._listdir(self._fn(self.module_path, resource_name))
+
+    def metadata_listdir(self, name):
+        if self.egg_info:
+            return self._listdir(self._fn(self.egg_info, name))
+        return []
+
+    def run_script(self, script_name, namespace):
+        script = 'scripts/' + script_name
+        if not self.has_metadata(script):
+            raise ResolutionError(
+                "Script {script!r} not found in metadata at {self.egg_info!r}"
+                .format(**locals()),
+            )
+        script_text = self.get_metadata(script).replace('\r\n', '\n')
+        script_text = script_text.replace('\r', '\n')
+        script_filename = self._fn(self.egg_info, script)
+        namespace['__file__'] = script_filename
+        if os.path.exists(script_filename):
+            source = open(script_filename).read()
+            code = compile(source, script_filename, 'exec')
+            exec(code, namespace, namespace)
+        else:
+            from linecache import cache
+            cache[script_filename] = (
+                len(script_text), 0, script_text.split('\n'), script_filename
+            )
+            script_code = compile(script_text, script_filename, 'exec')
+            exec(script_code, namespace, namespace)
+
+    def _has(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _isdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _listdir(self, path):
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _fn(self, base, resource_name):
+        self._validate_resource_path(resource_name)
+        if resource_name:
+            return os.path.join(base, *resource_name.split('/'))
+        return base
+
+    @staticmethod
+    def _validate_resource_path(path):
+        """
+        Validate the resource paths according to the docs.
+        https://setuptools.readthedocs.io/en/latest/pkg_resources.html#basic-resource-access
+
+        >>> warned = getfixture('recwarn')
+        >>> warnings.simplefilter('always')
+        >>> vrp = NullProvider._validate_resource_path
+        >>> vrp('foo/bar.txt')
+        >>> bool(warned)
+        False
+        >>> vrp('../foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('/foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> vrp('foo/../../bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('foo/f../bar.txt')
+        >>> bool(warned)
+        False
+
+        Windows path separators are straight-up disallowed.
+        >>> vrp(r'\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        >>> vrp(r'C:\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        Blank values are allowed
+
+        >>> vrp('')
+        >>> bool(warned)
+        False
+
+        Non-string values are not.
+
+        >>> vrp(None)
+        Traceback (most recent call last):
+        ...
+        AttributeError: ...
+        """
+        invalid = (
+            os.path.pardir in path.split(posixpath.sep) or
+            posixpath.isabs(path) or
+            ntpath.isabs(path)
+        )
+        if not invalid:
+            return
+
+        msg = "Use of .. or absolute path in a resource path is not allowed."
+
+        # Aggressively disallow Windows absolute paths
+        if ntpath.isabs(path) and not posixpath.isabs(path):
+            raise ValueError(msg)
+
+        # for compatibility, warn; in future
+        # raise ValueError(msg)
+        warnings.warn(
+            msg[:-1] + " and will raise exceptions in a future release.",
+            DeprecationWarning,
+            stacklevel=4,
+        )
+
+    def _get(self, path):
+        if hasattr(self.loader, 'get_data'):
+            return self.loader.get_data(path)
+        raise NotImplementedError(
+            "Can't perform this operation for loaders without 'get_data()'"
+        )
+
+
+register_loader_type(object, NullProvider)
+
+
+class EggProvider(NullProvider):
+    """Provider based on a virtual filesystem"""
+
+    def __init__(self, module):
+        NullProvider.__init__(self, module)
+        self._setup_prefix()
+
+    def _setup_prefix(self):
+        # we assume here that our metadata may be nested inside a "basket"
+        # of multiple eggs; that's why we use module_path instead of .archive
+        path = self.module_path
+        old = None
+        while path != old:
+            if _is_egg_path(path):
+                self.egg_name = os.path.basename(path)
+                self.egg_info = os.path.join(path, 'EGG-INFO')
+                self.egg_root = path
+                break
+            old = path
+            path, base = os.path.split(path)
+
+
+class DefaultProvider(EggProvider):
+    """Provides access to package resources in the filesystem"""
+
+    def _has(self, path):
+        return os.path.exists(path)
+
+    def _isdir(self, path):
+        return os.path.isdir(path)
+
+    def _listdir(self, path):
+        return os.listdir(path)
+
+    def get_resource_stream(self, manager, resource_name):
+        return open(self._fn(self.module_path, resource_name), 'rb')
+
+    def _get(self, path):
+        with open(path, 'rb') as stream:
+            return stream.read()
+
+    @classmethod
+    def _register(cls):
+        loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
+        for name in loader_names:
+            loader_cls = getattr(importlib_machinery, name, type(None))
+            register_loader_type(loader_cls, cls)
+
+
+DefaultProvider._register()
+
+
+class EmptyProvider(NullProvider):
+    """Provider that returns nothing for all requests"""
+
+    module_path = None
+
+    _isdir = _has = lambda self, path: False
+
+    def _get(self, path):
+        return ''
+
+    def _listdir(self, path):
+        return []
+
+    def __init__(self):
+        pass
+
+
+empty_provider = EmptyProvider()
+
+
+class ZipManifests(dict):
+    """
+    zip manifest builder
+    """
+
+    @classmethod
+    def build(cls, path):
+        """
+        Build a dictionary similar to the zipimport directory
+        caches, except instead of tuples, store ZipInfo objects.
+
+        Use a platform-specific path separator (os.sep) for the path keys
+        for compatibility with pypy on Windows.
+        """
+        with zipfile.ZipFile(path) as zfile:
+            items = (
+                (
+                    name.replace('/', os.sep),
+                    zfile.getinfo(name),
+                )
+                for name in zfile.namelist()
+            )
+            return dict(items)
+
+    load = build
+
+
+class MemoizedZipManifests(ZipManifests):
+    """
+    Memoized zipfile manifests.
+    """
+    manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
+
+    def load(self, path):
+        """
+        Load a manifest at path or return a suitable manifest already loaded.
+        """
+        path = os.path.normpath(path)
+        mtime = os.stat(path).st_mtime
+
+        if path not in self or self[path].mtime != mtime:
+            manifest = self.build(path)
+            self[path] = self.manifest_mod(manifest, mtime)
+
+        return self[path].manifest
+
+
+class ZipProvider(EggProvider):
+    """Resource support for zips and eggs"""
+
+    eagers = None
+    _zip_manifests = MemoizedZipManifests()
+
+    def __init__(self, module):
+        EggProvider.__init__(self, module)
+        self.zip_pre = self.loader.archive + os.sep
+
+    def _zipinfo_name(self, fspath):
+        # Convert a virtual filename (full path to file) into a zipfile subpath
+        # usable with the zipimport directory cache for our target archive
+        fspath = fspath.rstrip(os.sep)
+        if fspath == self.loader.archive:
+            return ''
+        if fspath.startswith(self.zip_pre):
+            return fspath[len(self.zip_pre):]
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.zip_pre)
+        )
+
+    def _parts(self, zip_path):
+        # Convert a zipfile subpath into an egg-relative path part list.
+        # pseudo-fs path
+        fspath = self.zip_pre + zip_path
+        if fspath.startswith(self.egg_root + os.sep):
+            return fspath[len(self.egg_root) + 1:].split(os.sep)
+        raise AssertionError(
+            "%s is not a subpath of %s" % (fspath, self.egg_root)
+        )
+
+    @property
+    def zipinfo(self):
+        return self._zip_manifests.load(self.loader.archive)
+
+    def get_resource_filename(self, manager, resource_name):
+        if not self.egg_name:
+            raise NotImplementedError(
+                "resource_filename() only supported for .egg, not .zip"
+            )
+        # no need to lock for extraction, since we use temp names
+        zip_path = self._resource_to_zip(resource_name)
+        eagers = self._get_eager_resources()
+        if '/'.join(self._parts(zip_path)) in eagers:
+            for name in eagers:
+                self._extract_resource(manager, self._eager_to_zip(name))
+        return self._extract_resource(manager, zip_path)
+
+    @staticmethod
+    def _get_date_and_size(zip_stat):
+        size = zip_stat.file_size
+        # ymdhms+wday, yday, dst
+        date_time = zip_stat.date_time + (0, 0, -1)
+        # 1980 offset already done
+        timestamp = time.mktime(date_time)
+        return timestamp, size
+
+    def _extract_resource(self, manager, zip_path):
+
+        if zip_path in self._index():
+            for name in self._index()[zip_path]:
+                last = self._extract_resource(
+                    manager, os.path.join(zip_path, name)
+                )
+            # return the extracted directory name
+            return os.path.dirname(last)
+
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+
+        if not WRITE_SUPPORT:
+            raise IOError('"os.rename" and "os.unlink" are not supported '
+                          'on this platform')
+        try:
+
+            real_path = manager.get_cache_path(
+                self.egg_name, self._parts(zip_path)
+            )
+
+            if self._is_current(real_path, zip_path):
+                return real_path
+
+            outf, tmpnam = _mkstemp(
+                ".$extract",
+                dir=os.path.dirname(real_path),
+            )
+            os.write(outf, self.loader.get_data(zip_path))
+            os.close(outf)
+            utime(tmpnam, (timestamp, timestamp))
+            manager.postprocess(tmpnam, real_path)
+
+            try:
+                rename(tmpnam, real_path)
+
+            except os.error:
+                if os.path.isfile(real_path):
+                    if self._is_current(real_path, zip_path):
+                        # the file became current since it was checked above,
+                        #  so proceed.
+                        return real_path
+                    # Windows, del old file and retry
+                    elif os.name == 'nt':
+                        unlink(real_path)
+                        rename(tmpnam, real_path)
+                        return real_path
+                raise
+
+        except os.error:
+            # report a user-friendly error
+            manager.extraction_error()
+
+        return real_path
+
+    def _is_current(self, file_path, zip_path):
+        """
+        Return True if the file_path is current for this zip_path
+        """
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+        if not os.path.isfile(file_path):
+            return False
+        stat = os.stat(file_path)
+        if stat.st_size != size or stat.st_mtime != timestamp:
+            return False
+        # check that the contents match
+        zip_contents = self.loader.get_data(zip_path)
+        with open(file_path, 'rb') as f:
+            file_contents = f.read()
+        return zip_contents == file_contents
+
+    def _get_eager_resources(self):
+        if self.eagers is None:
+            eagers = []
+            for name in ('native_libs.txt', 'eager_resources.txt'):
+                if self.has_metadata(name):
+                    eagers.extend(self.get_metadata_lines(name))
+            self.eagers = eagers
+        return self.eagers
+
+    def _index(self):
+        try:
+            return self._dirindex
+        except AttributeError:
+            ind = {}
+            for path in self.zipinfo:
+                parts = path.split(os.sep)
+                while parts:
+                    parent = os.sep.join(parts[:-1])
+                    if parent in ind:
+                        ind[parent].append(parts[-1])
+                        break
+                    else:
+                        ind[parent] = [parts.pop()]
+            self._dirindex = ind
+            return ind
+
+    def _has(self, fspath):
+        zip_path = self._zipinfo_name(fspath)
+        return zip_path in self.zipinfo or zip_path in self._index()
+
+    def _isdir(self, fspath):
+        return self._zipinfo_name(fspath) in self._index()
+
+    def _listdir(self, fspath):
+        return list(self._index().get(self._zipinfo_name(fspath), ()))
+
+    def _eager_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
+
+    def _resource_to_zip(self, resource_name):
+        return self._zipinfo_name(self._fn(self.module_path, resource_name))
+
+
+register_loader_type(zipimport.zipimporter, ZipProvider)
+
+
+class FileMetadata(EmptyProvider):
+    """Metadata handler for standalone PKG-INFO files
+
+    Usage::
+
+        metadata = FileMetadata("/path/to/PKG-INFO")
+
+    This provider rejects all data and metadata requests except for PKG-INFO,
+    which is treated as existing, and will be the contents of the file at
+    the provided location.
+    """
+
+    def __init__(self, path):
+        self.path = path
+
+    def _get_metadata_path(self, name):
+        return self.path
+
+    def has_metadata(self, name):
+        return name == 'PKG-INFO' and os.path.isfile(self.path)
+
+    def get_metadata(self, name):
+        if name != 'PKG-INFO':
+            raise KeyError("No metadata except PKG-INFO is available")
+
+        with io.open(self.path, encoding='utf-8', errors="replace") as f:
+            metadata = f.read()
+        self._warn_on_replacement(metadata)
+        return metadata
+
+    def _warn_on_replacement(self, metadata):
+        # Python 2.7 compat for: replacement_char = '�'
+        replacement_char = b'\xef\xbf\xbd'.decode('utf-8')
+        if replacement_char in metadata:
+            tmpl = "{self.path} could not be properly decoded in UTF-8"
+            msg = tmpl.format(**locals())
+            warnings.warn(msg)
+
+    def get_metadata_lines(self, name):
+        return yield_lines(self.get_metadata(name))
+
+
+class PathMetadata(DefaultProvider):
+    """Metadata provider for egg directories
+
+    Usage::
+
+        # Development eggs:
+
+        egg_info = "/path/to/PackageName.egg-info"
+        base_dir = os.path.dirname(egg_info)
+        metadata = PathMetadata(base_dir, egg_info)
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
+        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
+
+        # Unpacked egg directories:
+
+        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
+        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
+        dist = Distribution.from_filename(egg_path, metadata=metadata)
+    """
+
+    def __init__(self, path, egg_info):
+        self.module_path = path
+        self.egg_info = egg_info
+
+
+class EggMetadata(ZipProvider):
+    """Metadata provider for .egg files"""
+
+    def __init__(self, importer):
+        """Create a metadata provider from a zipimporter"""
+
+        self.zip_pre = importer.archive + os.sep
+        self.loader = importer
+        if importer.prefix:
+            self.module_path = os.path.join(importer.archive, importer.prefix)
+        else:
+            self.module_path = importer.archive
+        self._setup_prefix()
+
+
+_declare_state('dict', _distribution_finders={})
+
+
+def register_finder(importer_type, distribution_finder):
+    """Register `distribution_finder` to find distributions in sys.path items
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `distribution_finder` is a callable that, passed a path
+    item and the importer instance, yields ``Distribution`` instances found on
+    that path item.  See ``pkg_resources.find_on_path`` for an example."""
+    _distribution_finders[importer_type] = distribution_finder
+
+
+def find_distributions(path_item, only=False):
+    """Yield distributions accessible via `path_item`"""
+    importer = get_importer(path_item)
+    finder = _find_adapter(_distribution_finders, importer)
+    return finder(importer, path_item, only)
+
+
+def find_eggs_in_zip(importer, path_item, only=False):
+    """
+    Find eggs in zip files; possibly multiple nested eggs.
+    """
+    if importer.archive.endswith('.whl'):
+        # wheels are not supported with this finder
+        # they don't have PKG-INFO metadata, and won't ever contain eggs
+        return
+    metadata = EggMetadata(importer)
+    if metadata.has_metadata('PKG-INFO'):
+        yield Distribution.from_filename(path_item, metadata=metadata)
+    if only:
+        # don't yield nested distros
+        return
+    for subitem in metadata.resource_listdir(''):
+        if _is_egg_path(subitem):
+            subpath = os.path.join(path_item, subitem)
+            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
+            for dist in dists:
+                yield dist
+        elif subitem.lower().endswith('.dist-info'):
+            subpath = os.path.join(path_item, subitem)
+            submeta = EggMetadata(zipimport.zipimporter(subpath))
+            submeta.egg_info = subpath
+            yield Distribution.from_location(path_item, subitem, submeta)
+
+
+register_finder(zipimport.zipimporter, find_eggs_in_zip)
+
+
+def find_nothing(importer, path_item, only=False):
+    return ()
+
+
+register_finder(object, find_nothing)
+
+
+def _by_version_descending(names):
+    """
+    Given a list of filenames, return them in descending order
+    by version number.
+
+    >>> names = 'bar', 'foo', 'Python-2.7.10.egg', 'Python-2.7.2.egg'
+    >>> _by_version_descending(names)
+    ['Python-2.7.10.egg', 'Python-2.7.2.egg', 'foo', 'bar']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.egg', 'Setuptools-1.2.3b1.egg']
+    >>> names = 'Setuptools-1.2.3b1.egg', 'Setuptools-1.2.3.post1.egg'
+    >>> _by_version_descending(names)
+    ['Setuptools-1.2.3.post1.egg', 'Setuptools-1.2.3b1.egg']
+    """
+    def _by_version(name):
+        """
+        Parse each component of the filename
+        """
+        name, ext = os.path.splitext(name)
+        parts = itertools.chain(name.split('-'), [ext])
+        return [packaging.version.parse(part) for part in parts]
+
+    return sorted(names, key=_by_version, reverse=True)
+
+
+def find_on_path(importer, path_item, only=False):
+    """Yield distributions accessible on a sys.path directory"""
+    path_item = _normalize_cached(path_item)
+
+    if _is_unpacked_egg(path_item):
+        yield Distribution.from_filename(
+            path_item, metadata=PathMetadata(
+                path_item, os.path.join(path_item, 'EGG-INFO')
+            )
+        )
+        return
+
+    entries = safe_listdir(path_item)
+
+    # for performance, before sorting by version,
+    # screen entries for only those that will yield
+    # distributions
+    filtered = (
+        entry
+        for entry in entries
+        if dist_factory(path_item, entry, only)
+    )
+
+    # scan for .egg and .egg-info in directory
+    path_item_entries = _by_version_descending(filtered)
+    for entry in path_item_entries:
+        fullpath = os.path.join(path_item, entry)
+        factory = dist_factory(path_item, entry, only)
+        for dist in factory(fullpath):
+            yield dist
+
+
+def dist_factory(path_item, entry, only):
+    """
+    Return a dist_factory for a path_item and entry
+    """
+    lower = entry.lower()
+    is_meta = any(map(lower.endswith, ('.egg-info', '.dist-info')))
+    return (
+        distributions_from_metadata
+        if is_meta else
+        find_distributions
+        if not only and _is_egg_path(entry) else
+        resolve_egg_link
+        if not only and lower.endswith('.egg-link') else
+        NoDists()
+    )
+
+
+class NoDists:
+    """
+    >>> bool(NoDists())
+    False
+
+    >>> list(NoDists()('anything'))
+    []
+    """
+    def __bool__(self):
+        return False
+    if six.PY2:
+        __nonzero__ = __bool__
+
+    def __call__(self, fullpath):
+        return iter(())
+
+
+def safe_listdir(path):
+    """
+    Attempt to list contents of path, but suppress some exceptions.
+    """
+    try:
+        return os.listdir(path)
+    except (PermissionError, NotADirectoryError):
+        pass
+    except OSError as e:
+        # Ignore the directory if does not exist, not a directory or
+        # permission denied
+        ignorable = (
+            e.errno in (errno.ENOTDIR, errno.EACCES, errno.ENOENT)
+            # Python 2 on Windows needs to be handled this way :(
+            or getattr(e, "winerror", None) == 267
+        )
+        if not ignorable:
+            raise
+    return ()
+
+
+def distributions_from_metadata(path):
+    root = os.path.dirname(path)
+    if os.path.isdir(path):
+        if len(os.listdir(path)) == 0:
+            # empty metadata dir; skip
+            return
+        metadata = PathMetadata(root, path)
+    else:
+        metadata = FileMetadata(path)
+    entry = os.path.basename(path)
+    yield Distribution.from_location(
+        root, entry, metadata, precedence=DEVELOP_DIST,
+    )
+
+
+def non_empty_lines(path):
+    """
+    Yield non-empty lines from file at path
+    """
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield line
+
+
+def resolve_egg_link(path):
+    """
+    Given a path to an .egg-link, resolve distributions
+    present in the referenced path.
+    """
+    referenced_paths = non_empty_lines(path)
+    resolved_paths = (
+        os.path.join(os.path.dirname(path), ref)
+        for ref in referenced_paths
+    )
+    dist_groups = map(find_distributions, resolved_paths)
+    return next(dist_groups, ())
+
+
+register_finder(pkgutil.ImpImporter, find_on_path)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_finder(importlib_machinery.FileFinder, find_on_path)
+
+_declare_state('dict', _namespace_handlers={})
+_declare_state('dict', _namespace_packages={})
+
+
+def register_namespace_handler(importer_type, namespace_handler):
+    """Register `namespace_handler` to declare namespace packages
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `namespace_handler` is a callable like this::
+
+        def namespace_handler(importer, path_entry, moduleName, module):
+            # return a path_entry to use for child packages
+
+    Namespace handlers are only called if the importer object has already
+    agreed that it can handle the relevant path item, and they should only
+    return a subpath if the module __path__ does not already contain an
+    equivalent subpath.  For an example namespace handler, see
+    ``pkg_resources.file_ns_handler``.
+    """
+    _namespace_handlers[importer_type] = namespace_handler
+
+
+def _handle_ns(packageName, path_item):
+    """Ensure that named package includes a subpath of path_item (if needed)"""
+
+    importer = get_importer(path_item)
+    if importer is None:
+        return None
+
+    # capture warnings due to #1111
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        loader = importer.find_module(packageName)
+
+    if loader is None:
+        return None
+    module = sys.modules.get(packageName)
+    if module is None:
+        module = sys.modules[packageName] = types.ModuleType(packageName)
+        module.__path__ = []
+        _set_parent_ns(packageName)
+    elif not hasattr(module, '__path__'):
+        raise TypeError("Not a package:", packageName)
+    handler = _find_adapter(_namespace_handlers, importer)
+    subpath = handler(importer, path_item, packageName, module)
+    if subpath is not None:
+        path = module.__path__
+        path.append(subpath)
+        loader.load_module(packageName)
+        _rebuild_mod_path(path, packageName, module)
+    return subpath
+
+
+def _rebuild_mod_path(orig_path, package_name, module):
+    """
+    Rebuild module.__path__ ensuring that all entries are ordered
+    corresponding to their sys.path order
+    """
+    sys_path = [_normalize_cached(p) for p in sys.path]
+
+    def safe_sys_path_index(entry):
+        """
+        Workaround for #520 and #513.
+        """
+        try:
+            return sys_path.index(entry)
+        except ValueError:
+            return float('inf')
+
+    def position_in_sys_path(path):
+        """
+        Return the ordinal of the path based on its position in sys.path
+        """
+        path_parts = path.split(os.sep)
+        module_parts = package_name.count('.') + 1
+        parts = path_parts[:-module_parts]
+        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
+
+    new_path = sorted(orig_path, key=position_in_sys_path)
+    new_path = [_normalize_cached(p) for p in new_path]
+
+    if isinstance(module.__path__, list):
+        module.__path__[:] = new_path
+    else:
+        module.__path__ = new_path
+
+
+def declare_namespace(packageName):
+    """Declare that package 'packageName' is a namespace package"""
+
+    _imp.acquire_lock()
+    try:
+        if packageName in _namespace_packages:
+            return
+
+        path = sys.path
+        parent, _, _ = packageName.rpartition('.')
+
+        if parent:
+            declare_namespace(parent)
+            if parent not in _namespace_packages:
+                __import__(parent)
+            try:
+                path = sys.modules[parent].__path__
+            except AttributeError:
+                raise TypeError("Not a package:", parent)
+
+        # Track what packages are namespaces, so when new path items are added,
+        # they can be updated
+        _namespace_packages.setdefault(parent or None, []).append(packageName)
+        _namespace_packages.setdefault(packageName, [])
+
+        for path_item in path:
+            # Ensure all the parent's path items are reflected in the child,
+            # if they apply
+            _handle_ns(packageName, path_item)
+
+    finally:
+        _imp.release_lock()
+
+
+def fixup_namespace_packages(path_item, parent=None):
+    """Ensure that previously-declared namespace packages include path_item"""
+    _imp.acquire_lock()
+    try:
+        for package in _namespace_packages.get(parent, ()):
+            subpath = _handle_ns(package, path_item)
+            if subpath:
+                fixup_namespace_packages(subpath, package)
+    finally:
+        _imp.release_lock()
+
+
+def file_ns_handler(importer, path_item, packageName, module):
+    """Compute an ns-package subpath for a filesystem or zipfile importer"""
+
+    subpath = os.path.join(path_item, packageName.split('.')[-1])
+    normalized = _normalize_cached(subpath)
+    for item in module.__path__:
+        if _normalize_cached(item) == normalized:
+            break
+    else:
+        # Only return the path if it's not already there
+        return subpath
+
+
+register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+register_namespace_handler(zipimport.zipimporter, file_ns_handler)
+
+if hasattr(importlib_machinery, 'FileFinder'):
+    register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
+
+
+def null_ns_handler(importer, path_item, packageName, module):
+    return None
+
+
+register_namespace_handler(object, null_ns_handler)
+
+
+def normalize_path(filename):
+    """Normalize a file/dir name for comparison purposes"""
+    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
+
+
+def _cygwin_patch(filename):  # pragma: nocover
+    """
+    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
+    symlink components. Using
+    os.path.abspath() works around this limitation. A fix in os.getcwd()
+    would probably better, in Cygwin even more so, except
+    that this seems to be by design...
+    """
+    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
+
+
+def _normalize_cached(filename, _cache={}):
+    try:
+        return _cache[filename]
+    except KeyError:
+        _cache[filename] = result = normalize_path(filename)
+        return result
+
+
+def _is_egg_path(path):
+    """
+    Determine if given path appears to be an egg.
+    """
+    return path.lower().endswith('.egg')
+
+
+def _is_unpacked_egg(path):
+    """
+    Determine if given path appears to be an unpacked egg.
+    """
+    return (
+        _is_egg_path(path) and
+        os.path.isfile(os.path.join(path, 'EGG-INFO', 'PKG-INFO'))
+    )
+
+
+def _set_parent_ns(packageName):
+    parts = packageName.split('.')
+    name = parts.pop()
+    if parts:
+        parent = '.'.join(parts)
+        setattr(sys.modules[parent], name, sys.modules[packageName])
+
+
+def yield_lines(strs):
+    """Yield non-empty/non-comment lines of a string or sequence"""
+    if isinstance(strs, six.string_types):
+        for s in strs.splitlines():
+            s = s.strip()
+            # skip blank lines/comments
+            if s and not s.startswith('#'):
+                yield s
+    else:
+        for ss in strs:
+            for s in yield_lines(ss):
+                yield s
+
+
+MODULE = re.compile(r"\w+(\.\w+)*$").match
+EGG_NAME = re.compile(
+    r"""
+    (?P<name>[^-]+) (
+        -(?P<ver>[^-]+) (
+            -py(?P<pyver>[^-]+) (
+                -(?P<plat>.+)
+            )?
+        )?
+    )?
+    """,
+    re.VERBOSE | re.IGNORECASE,
+).match
+
+
+class EntryPoint:
+    """Object representing an advertised importable object"""
+
+    def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
+        if not MODULE(module_name):
+            raise ValueError("Invalid module name", module_name)
+        self.name = name
+        self.module_name = module_name
+        self.attrs = tuple(attrs)
+        self.extras = tuple(extras)
+        self.dist = dist
+
+    def __str__(self):
+        s = "%s = %s" % (self.name, self.module_name)
+        if self.attrs:
+            s += ':' + '.'.join(self.attrs)
+        if self.extras:
+            s += ' [%s]' % ','.join(self.extras)
+        return s
+
+    def __repr__(self):
+        return "EntryPoint.parse(%r)" % str(self)
+
+    def load(self, require=True, *args, **kwargs):
+        """
+        Require packages for this EntryPoint, then resolve it.
+        """
+        if not require or args or kwargs:
+            warnings.warn(
+                "Parameters to load are deprecated.  Call .resolve and "
+                ".require separately.",
+                PkgResourcesDeprecationWarning,
+                stacklevel=2,
+            )
+        if require:
+            self.require(*args, **kwargs)
+        return self.resolve()
+
+    def resolve(self):
+        """
+        Resolve the entry point from its module and attrs.
+        """
+        module = __import__(self.module_name, fromlist=['__name__'], level=0)
+        try:
+            return functools.reduce(getattr, self.attrs, module)
+        except AttributeError as exc:
+            raise ImportError(str(exc))
+
+    def require(self, env=None, installer=None):
+        if self.extras and not self.dist:
+            raise UnknownExtra("Can't require() without a distribution", self)
+
+        # Get the requirements for this entry point with all its extras and
+        # then resolve them. We have to pass `extras` along when resolving so
+        # that the working set knows what extras we want. Otherwise, for
+        # dist-info distributions, the working set will assume that the
+        # requirements for that extra are purely optional and skip over them.
+        reqs = self.dist.requires(self.extras)
+        items = working_set.resolve(reqs, env, installer, extras=self.extras)
+        list(map(working_set.add, items))
+
+    pattern = re.compile(
+        r'\s*'
+        r'(?P<name>.+?)\s*'
+        r'=\s*'
+        r'(?P<module>[\w.]+)\s*'
+        r'(:\s*(?P<attr>[\w.]+))?\s*'
+        r'(?P<extras>\[.*\])?\s*$'
+    )
+
+    @classmethod
+    def parse(cls, src, dist=None):
+        """Parse a single entry point from string `src`
+
+        Entry point syntax follows the form::
+
+            name = some.module:some.attr [extra1, extra2]
+
+        The entry name and module name are required, but the ``:attrs`` and
+        ``[extras]`` parts are optional
+        """
+        m = cls.pattern.match(src)
+        if not m:
+            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
+            raise ValueError(msg, src)
+        res = m.groupdict()
+        extras = cls._parse_extras(res['extras'])
+        attrs = res['attr'].split('.') if res['attr'] else ()
+        return cls(res['name'], res['module'], attrs, extras, dist)
+
+    @classmethod
+    def _parse_extras(cls, extras_spec):
+        if not extras_spec:
+            return ()
+        req = Requirement.parse('x' + extras_spec)
+        if req.specs:
+            raise ValueError()
+        return req.extras
+
+    @classmethod
+    def parse_group(cls, group, lines, dist=None):
+        """Parse an entry point group"""
+        if not MODULE(group):
+            raise ValueError("Invalid group name", group)
+        this = {}
+        for line in yield_lines(lines):
+            ep = cls.parse(line, dist)
+            if ep.name in this:
+                raise ValueError("Duplicate entry point", group, ep.name)
+            this[ep.name] = ep
+        return this
+
+    @classmethod
+    def parse_map(cls, data, dist=None):
+        """Parse a map of entry point groups"""
+        if isinstance(data, dict):
+            data = data.items()
+        else:
+            data = split_sections(data)
+        maps = {}
+        for group, lines in data:
+            if group is None:
+                if not lines:
+                    continue
+                raise ValueError("Entry points must be listed in groups")
+            group = group.strip()
+            if group in maps:
+                raise ValueError("Duplicate group name", group)
+            maps[group] = cls.parse_group(group, lines, dist)
+        return maps
+
+
+def _remove_md5_fragment(location):
+    if not location:
+        return ''
+    parsed = urllib.parse.urlparse(location)
+    if parsed[-1].startswith('md5='):
+        return urllib.parse.urlunparse(parsed[:-1] + ('',))
+    return location
+
+
+def _version_from_file(lines):
+    """
+    Given an iterable of lines from a Metadata file, return
+    the value of the Version field, if present, or None otherwise.
+    """
+    def is_version_line(line):
+        return line.lower().startswith('version:')
+    version_lines = filter(is_version_line, lines)
+    line = next(iter(version_lines), '')
+    _, _, value = line.partition(':')
+    return safe_version(value.strip()) or None
+
+
+class Distribution:
+    """Wrap an actual or potential sys.path entry w/metadata"""
+    PKG_INFO = 'PKG-INFO'
+
+    def __init__(
+            self, location=None, metadata=None, project_name=None,
+            version=None, py_version=PY_MAJOR, platform=None,
+            precedence=EGG_DIST):
+        self.project_name = safe_name(project_name or 'Unknown')
+        if version is not None:
+            self._version = safe_version(version)
+        self.py_version = py_version
+        self.platform = platform
+        self.location = location
+        self.precedence = precedence
+        self._provider = metadata or empty_provider
+
+    @classmethod
+    def from_location(cls, location, basename, metadata=None, **kw):
+        project_name, version, py_version, platform = [None] * 4
+        basename, ext = os.path.splitext(basename)
+        if ext.lower() in _distributionImpl:
+            cls = _distributionImpl[ext.lower()]
+
+            match = EGG_NAME(basename)
+            if match:
+                project_name, version, py_version, platform = match.group(
+                    'name', 'ver', 'pyver', 'plat'
+                )
+        return cls(
+            location, metadata, project_name=project_name, version=version,
+            py_version=py_version, platform=platform, **kw
+        )._reload_version()
+
+    def _reload_version(self):
+        return self
+
+    @property
+    def hashcmp(self):
+        return (
+            self.parsed_version,
+            self.precedence,
+            self.key,
+            _remove_md5_fragment(self.location),
+            self.py_version or '',
+            self.platform or '',
+        )
+
+    def __hash__(self):
+        return hash(self.hashcmp)
+
+    def __lt__(self, other):
+        return self.hashcmp < other.hashcmp
+
+    def __le__(self, other):
+        return self.hashcmp <= other.hashcmp
+
+    def __gt__(self, other):
+        return self.hashcmp > other.hashcmp
+
+    def __ge__(self, other):
+        return self.hashcmp >= other.hashcmp
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            # It's not a Distribution, so they are not equal
+            return False
+        return self.hashcmp == other.hashcmp
+
+    def __ne__(self, other):
+        return not self == other
+
+    # These properties have to be lazy so that we don't have to load any
+    # metadata until/unless it's actually needed.  (i.e., some distributions
+    # may not know their name or version without loading PKG-INFO)
+
+    @property
+    def key(self):
+        try:
+            return self._key
+        except AttributeError:
+            self._key = key = self.project_name.lower()
+            return key
+
+    @property
+    def parsed_version(self):
+        if not hasattr(self, "_parsed_version"):
+            self._parsed_version = parse_version(self.version)
+
+        return self._parsed_version
+
+    def _warn_legacy_version(self):
+        LV = packaging.version.LegacyVersion
+        is_legacy = isinstance(self._parsed_version, LV)
+        if not is_legacy:
+            return
+
+        # While an empty version is technically a legacy version and
+        # is not a valid PEP 440 version, it's also unlikely to
+        # actually come from someone and instead it is more likely that
+        # it comes from setuptools attempting to parse a filename and
+        # including it in the list. So for that we'll gate this warning
+        # on if the version is anything at all or not.
+        if not self.version:
+            return
+
+        tmpl = textwrap.dedent("""
+            '{project_name} ({version})' is being parsed as a legacy,
+            non PEP 440,
+            version. You may find odd behavior and sort order.
+            In particular it will be sorted as less than 0.0. It
+            is recommended to migrate to PEP 440 compatible
+            versions.
+            """).strip().replace('\n', ' ')
+
+        warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
+
+    @property
+    def version(self):
+        try:
+            return self._version
+        except AttributeError:
+            version = self._get_version()
+            if version is None:
+                path = self._get_metadata_path_for_display(self.PKG_INFO)
+                msg = (
+                    "Missing 'Version:' header and/or {} file at path: {}"
+                ).format(self.PKG_INFO, path)
+                raise ValueError(msg, self)
+
+            return version
+
+    @property
+    def _dep_map(self):
+        """
+        A map of extra to its list of (direct) requirements
+        for this distribution, including the null extra.
+        """
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._filter_extras(self._build_dep_map())
+        return self.__dep_map
+
+    @staticmethod
+    def _filter_extras(dm):
+        """
+        Given a mapping of extras to dependencies, strip off
+        environment markers and filter out any dependencies
+        not matching the markers.
+        """
+        for extra in list(filter(None, dm)):
+            new_extra = extra
+            reqs = dm.pop(extra)
+            new_extra, _, marker = extra.partition(':')
+            fails_marker = marker and (
+                invalid_marker(marker)
+                or not evaluate_marker(marker)
+            )
+            if fails_marker:
+                reqs = []
+            new_extra = safe_extra(new_extra) or None
+
+            dm.setdefault(new_extra, []).extend(reqs)
+        return dm
+
+    def _build_dep_map(self):
+        dm = {}
+        for name in 'requires.txt', 'depends.txt':
+            for extra, reqs in split_sections(self._get_metadata(name)):
+                dm.setdefault(extra, []).extend(parse_requirements(reqs))
+        return dm
+
+    def requires(self, extras=()):
+        """List of Requirements needed for this distro if `extras` are used"""
+        dm = self._dep_map
+        deps = []
+        deps.extend(dm.get(None, ()))
+        for ext in extras:
+            try:
+                deps.extend(dm[safe_extra(ext)])
+            except KeyError:
+                raise UnknownExtra(
+                    "%s has no such extra feature %r" % (self, ext)
+                )
+        return deps
+
+    def _get_metadata_path_for_display(self, name):
+        """
+        Return the path to the given metadata file, if available.
+        """
+        try:
+            # We need to access _get_metadata_path() on the provider object
+            # directly rather than through this class's __getattr__()
+            # since _get_metadata_path() is marked private.
+            path = self._provider._get_metadata_path(name)
+
+        # Handle exceptions e.g. in case the distribution's metadata
+        # provider doesn't support _get_metadata_path().
+        except Exception:
+            return '[could not detect]'
+
+        return path
+
+    def _get_metadata(self, name):
+        if self.has_metadata(name):
+            for line in self.get_metadata_lines(name):
+                yield line
+
+    def _get_version(self):
+        lines = self._get_metadata(self.PKG_INFO)
+        version = _version_from_file(lines)
+
+        return version
+
+    def activate(self, path=None, replace=False):
+        """Ensure distribution is importable on `path` (default=sys.path)"""
+        if path is None:
+            path = sys.path
+        self.insert_on(path, replace=replace)
+        if path is sys.path:
+            fixup_namespace_packages(self.location)
+            for pkg in self._get_metadata('namespace_packages.txt'):
+                if pkg in sys.modules:
+                    declare_namespace(pkg)
+
+    def egg_name(self):
+        """Return what this distribution's standard .egg filename should be"""
+        filename = "%s-%s-py%s" % (
+            to_filename(self.project_name), to_filename(self.version),
+            self.py_version or PY_MAJOR
+        )
+
+        if self.platform:
+            filename += '-' + self.platform
+        return filename
+
+    def __repr__(self):
+        if self.location:
+            return "%s (%s)" % (self, self.location)
+        else:
+            return str(self)
+
+    def __str__(self):
+        try:
+            version = getattr(self, 'version', None)
+        except ValueError:
+            version = None
+        version = version or "[unknown version]"
+        return "%s %s" % (self.project_name, version)
+
+    def __getattr__(self, attr):
+        """Delegate all unrecognized public attributes to .metadata provider"""
+        if attr.startswith('_'):
+            raise AttributeError(attr)
+        return getattr(self._provider, attr)
+
+    def __dir__(self):
+        return list(
+            set(super(Distribution, self).__dir__())
+            | set(
+                attr for attr in self._provider.__dir__()
+                if not attr.startswith('_')
+            )
+        )
+
+    if not hasattr(object, '__dir__'):
+        # python 2.7 not supported
+        del __dir__
+
+    @classmethod
+    def from_filename(cls, filename, metadata=None, **kw):
+        return cls.from_location(
+            _normalize_cached(filename), os.path.basename(filename), metadata,
+            **kw
+        )
+
+    def as_requirement(self):
+        """Return a ``Requirement`` that matches this distribution exactly"""
+        if isinstance(self.parsed_version, packaging.version.Version):
+            spec = "%s==%s" % (self.project_name, self.parsed_version)
+        else:
+            spec = "%s===%s" % (self.project_name, self.parsed_version)
+
+        return Requirement.parse(spec)
+
+    def load_entry_point(self, group, name):
+        """Return the `name` entry point of `group` or raise ImportError"""
+        ep = self.get_entry_info(group, name)
+        if ep is None:
+            raise ImportError("Entry point %r not found" % ((group, name),))
+        return ep.load()
+
+    def get_entry_map(self, group=None):
+        """Return the entry point map for `group`, or the full entry map"""
+        try:
+            ep_map = self._ep_map
+        except AttributeError:
+            ep_map = self._ep_map = EntryPoint.parse_map(
+                self._get_metadata('entry_points.txt'), self
+            )
+        if group is not None:
+            return ep_map.get(group, {})
+        return ep_map
+
+    def get_entry_info(self, group, name):
+        """Return the EntryPoint object for `group`+`name`, or ``None``"""
+        return self.get_entry_map(group).get(name)
+
+    def insert_on(self, path, loc=None, replace=False):
+        """Ensure self.location is on path
+
+        If replace=False (default):
+            - If location is already in path anywhere, do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent.
+              - Else: add to the end of path.
+        If replace=True:
+            - If location is already on path anywhere (not eggs)
+              or higher priority than its parent (eggs)
+              do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent,
+                removing any lower-priority entries.
+              - Else: add it to the front of path.
+        """
+
+        loc = loc or self.location
+        if not loc:
+            return
+
+        nloc = _normalize_cached(loc)
+        bdir = os.path.dirname(nloc)
+        npath = [(p and _normalize_cached(p) or p) for p in path]
+
+        for p, item in enumerate(npath):
+            if item == nloc:
+                if replace:
+                    break
+                else:
+                    # don't modify path (even removing duplicates) if
+                    # found and not replace
+                    return
+            elif item == bdir and self.precedence == EGG_DIST:
+                # if it's an .egg, give it precedence over its directory
+                # UNLESS it's already been added to sys.path and replace=False
+                if (not replace) and nloc in npath[p:]:
+                    return
+                if path is sys.path:
+                    self.check_version_conflict()
+                path.insert(p, loc)
+                npath.insert(p, nloc)
+                break
+        else:
+            if path is sys.path:
+                self.check_version_conflict()
+            if replace:
+                path.insert(0, loc)
+            else:
+                path.append(loc)
+            return
+
+        # p is the spot where we found or inserted loc; now remove duplicates
+        while True:
+            try:
+                np = npath.index(nloc, p + 1)
+            except ValueError:
+                break
+            else:
+                del npath[np], path[np]
+                # ha!
+                p = np
+
+        return
+
+    def check_version_conflict(self):
+        if self.key == 'setuptools':
+            # ignore the inevitable setuptools self-conflicts  :(
+            return
+
+        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
+        loc = normalize_path(self.location)
+        for modname in self._get_metadata('top_level.txt'):
+            if (modname not in sys.modules or modname in nsp
+                    or modname in _namespace_packages):
+                continue
+            if modname in ('pkg_resources', 'setuptools', 'site'):
+                continue
+            fn = getattr(sys.modules[modname], '__file__', None)
+            if fn and (normalize_path(fn).startswith(loc) or
+                       fn.startswith(self.location)):
+                continue
+            issue_warning(
+                "Module %s was already imported from %s, but %s is being added"
+                " to sys.path" % (modname, fn, self.location),
+            )
+
+    def has_version(self):
+        try:
+            self.version
+        except ValueError:
+            issue_warning("Unbuilt egg for " + repr(self))
+            return False
+        return True
+
+    def clone(self, **kw):
+        """Copy this distribution, substituting in any changed keyword args"""
+        names = 'project_name version py_version platform location precedence'
+        for attr in names.split():
+            kw.setdefault(attr, getattr(self, attr, None))
+        kw.setdefault('metadata', self._provider)
+        return self.__class__(**kw)
+
+    @property
+    def extras(self):
+        return [dep for dep in self._dep_map if dep]
+
+
+class EggInfoDistribution(Distribution):
+    def _reload_version(self):
+        """
+        Packages installed by distutils (e.g. numpy or scipy),
+        which uses an old safe_version, and so
+        their version numbers can get mangled when
+        converted to filenames (e.g., 1.11.0.dev0+2329eae to
+        1.11.0.dev0_2329eae). These distributions will not be
+        parsed properly
+        downstream by Distribution and safe_version, so
+        take an extra step and try to get the version number from
+        the metadata file itself instead of the filename.
+        """
+        md_version = self._get_version()
+        if md_version:
+            self._version = md_version
+        return self
+
+
+class DistInfoDistribution(Distribution):
+    """
+    Wrap an actual or potential sys.path entry
+    w/metadata, .dist-info style.
+    """
+    PKG_INFO = 'METADATA'
+    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
+
+    @property
+    def _parsed_pkg_info(self):
+        """Parse and cache metadata"""
+        try:
+            return self._pkg_info
+        except AttributeError:
+            metadata = self.get_metadata(self.PKG_INFO)
+            self._pkg_info = email.parser.Parser().parsestr(metadata)
+            return self._pkg_info
+
+    @property
+    def _dep_map(self):
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._compute_dependencies()
+            return self.__dep_map
+
+    def _compute_dependencies(self):
+        """Recompute this distribution's dependencies."""
+        dm = self.__dep_map = {None: []}
+
+        reqs = []
+        # Including any condition expressions
+        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
+            reqs.extend(parse_requirements(req))
+
+        def reqs_for_extra(extra):
+            for req in reqs:
+                if not req.marker or req.marker.evaluate({'extra': extra}):
+                    yield req
+
+        common = frozenset(reqs_for_extra(None))
+        dm[None].extend(common)
+
+        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
+            s_extra = safe_extra(extra.strip())
+            dm[s_extra] = list(frozenset(reqs_for_extra(extra)) - common)
+
+        return dm
+
+
+_distributionImpl = {
+    '.egg': Distribution,
+    '.egg-info': EggInfoDistribution,
+    '.dist-info': DistInfoDistribution,
+}
+
+
+def issue_warning(*args, **kw):
+    level = 1
+    g = globals()
+    try:
+        # find the first stack frame that is *not* code in
+        # the pkg_resources module, to use for the warning
+        while sys._getframe(level).f_globals is g:
+            level += 1
+    except ValueError:
+        pass
+    warnings.warn(stacklevel=level + 1, *args, **kw)
+
+
+class RequirementParseError(ValueError):
+    def __str__(self):
+        return ' '.join(self.args)
+
+
+def parse_requirements(strs):
+    """Yield ``Requirement`` objects for each specification in `strs`
+
+    `strs` must be a string, or a (possibly-nested) iterable thereof.
+    """
+    # create a steppable iterator, so we can handle \-continuations
+    lines = iter(yield_lines(strs))
+
+    for line in lines:
+        # Drop comments -- a hash without a space may be in a URL.
+        if ' #' in line:
+            line = line[:line.find(' #')]
+        # If there is a line continuation, drop it, and append the next line.
+        if line.endswith('\\'):
+            line = line[:-2].strip()
+            try:
+                line += next(lines)
+            except StopIteration:
+                return
+        yield Requirement(line)
+
+
+class Requirement(packaging.requirements.Requirement):
+    def __init__(self, requirement_string):
+        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
+        try:
+            super(Requirement, self).__init__(requirement_string)
+        except packaging.requirements.InvalidRequirement as e:
+            raise RequirementParseError(str(e))
+        self.unsafe_name = self.name
+        project_name = safe_name(self.name)
+        self.project_name, self.key = project_name, project_name.lower()
+        self.specs = [
+            (spec.operator, spec.version) for spec in self.specifier]
+        self.extras = tuple(map(safe_extra, self.extras))
+        self.hashCmp = (
+            self.key,
+            self.specifier,
+            frozenset(self.extras),
+            str(self.marker) if self.marker else None,
+        )
+        self.__hash = hash(self.hashCmp)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Requirement) and
+            self.hashCmp == other.hashCmp
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __contains__(self, item):
+        if isinstance(item, Distribution):
+            if item.key != self.key:
+                return False
+
+            item = item.version
+
+        # Allow prereleases always in order to match the previous behavior of
+        # this method. In the future this should be smarter and follow PEP 440
+        # more accurately.
+        return self.specifier.contains(item, prereleases=True)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __repr__(self):
+        return "Requirement.parse(%r)" % str(self)
+
+    @staticmethod
+    def parse(s):
+        req, = parse_requirements(s)
+        return req
+
+
+def _always_object(classes):
+    """
+    Ensure object appears in the mro even
+    for old-style classes.
+    """
+    if object not in classes:
+        return classes + (object,)
+    return classes
+
+
+def _find_adapter(registry, ob):
+    """Return an adapter factory for `ob` from `registry`"""
+    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
+    for t in types:
+        if t in registry:
+            return registry[t]
+
+
+def ensure_directory(path):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    py31compat.makedirs(dirname, exist_ok=True)
+
+
+def _bypass_ensure_directory(path):
+    """Sandbox-bypassing version of ensure_directory()"""
+    if not WRITE_SUPPORT:
+        raise IOError('"os.mkdir" not supported on this platform.')
+    dirname, filename = split(path)
+    if dirname and filename and not isdir(dirname):
+        _bypass_ensure_directory(dirname)
+        try:
+            mkdir(dirname, 0o755)
+        except FileExistsError:
+            pass
+
+
+def split_sections(s):
+    """Split a string or iterable thereof into (section, content) pairs
+
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def _mkstemp(*args, **kw):
+    old_open = os.open
+    try:
+        # temporarily bypass sandboxing
+        os.open = os_open
+        return tempfile.mkstemp(*args, **kw)
+    finally:
+        # and then put it back
+        os.open = old_open
+
+
+# Silence the PEP440Warning by default, so that end users don't get hit by it
+# randomly just because they use pkg_resources. We want to append the rule
+# because we want earlier uses of filterwarnings to take precedence over this
+# one.
+warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
+
+
+# from jaraco.functools 1.3
+def _call_aside(f, *args, **kwargs):
+    f(*args, **kwargs)
+    return f
+
+
+@_call_aside
+def _initialize(g=globals()):
+    "Set up global resource manager (deliberately not state-saved)"
+    manager = ResourceManager()
+    g['_manager'] = manager
+    g.update(
+        (name, getattr(manager, name))
+        for name in dir(manager)
+        if not name.startswith('_')
+    )
+
+
+@_call_aside
+def _initialize_master_working_set():
+    """
+    Prepare the master working set and make the ``require()``
+    API available.
+
+    This function has explicit effects on the global state
+    of pkg_resources. It is intended to be invoked once at
+    the initialization of this module.
+
+    Invocation by other packages is unsupported and done
+    at their own risk.
+    """
+    working_set = WorkingSet._build_master()
+    _declare_state('object', working_set=working_set)
+
+    require = working_set.require
+    iter_entry_points = working_set.iter_entry_points
+    add_activation_listener = working_set.subscribe
+    run_script = working_set.run_script
+    # backward compatibility
+    run_main = run_script
+    # Activate all distributions already on sys.path with replace=False and
+    # ensure that all distributions added to the working set in the future
+    # (e.g. by calling ``require()``) will get activated as well,
+    # with higher priority (replace=True).
+    tuple(
+        dist.activate(replace=False)
+        for dist in working_set
+    )
+    add_activation_listener(
+        lambda dist: dist.activate(replace=True),
+        existing=False,
+    )
+    working_set.entries = []
+    # match order
+    list(map(working_set.add_entry, sys.path))
+    globals().update(locals())
+
+class PkgResourcesDeprecationWarning(Warning):
+    """
+    Base class for warning about deprecations in ``pkg_resources``
+
+    This class is not derived from ``DeprecationWarning``, and as such is
+    visible by default.
+    """
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/py31compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/py31compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2d3007ceb16b0eeb4b1f57361c089558a25daeb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pkg_resources/py31compat.py
@@ -0,0 +1,23 @@
+import os
+import errno
+import sys
+
+from pip._vendor import six
+
+
+def _makedirs_31(path, exist_ok=False):
+    try:
+        os.makedirs(path)
+    except OSError as exc:
+        if not exist_ok or exc.errno != errno.EEXIST:
+            raise
+
+
+# rely on compatibility behavior until mode considerations
+#  and exists_ok considerations are disentangled.
+# See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663
+needs_makedirs = (
+    six.PY2 or
+    (3, 4) <= sys.version_info < (3, 4, 1)
+)
+makedirs = _makedirs_31 if needs_makedirs else os.makedirs
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e434c257fefd4eda43f5daf5b8dcf7d4cf9da30b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/__init__.py
@@ -0,0 +1,177 @@
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+from __future__ import division, print_function
+
+from collections import deque
+from datetime import timedelta
+from math import ceil
+from sys import stderr
+try:
+    from time import monotonic
+except ImportError:
+    from time import time as monotonic
+
+
+__version__ = '1.5'
+
+HIDE_CURSOR = '\x1b[?25l'
+SHOW_CURSOR = '\x1b[?25h'
+
+
+class Infinite(object):
+    file = stderr
+    sma_window = 10         # Simple Moving Average window
+    check_tty = True
+    hide_cursor = True
+
+    def __init__(self, message='', **kwargs):
+        self.index = 0
+        self.start_ts = monotonic()
+        self.avg = 0
+        self._avg_update_ts = self.start_ts
+        self._ts = self.start_ts
+        self._xput = deque(maxlen=self.sma_window)
+        for key, val in kwargs.items():
+            setattr(self, key, val)
+
+        self._width = 0
+        self.message = message
+
+        if self.file and self.is_tty():
+            if self.hide_cursor:
+                print(HIDE_CURSOR, end='', file=self.file)
+            print(self.message, end='', file=self.file)
+            self.file.flush()
+
+    def __getitem__(self, key):
+        if key.startswith('_'):
+            return None
+        return getattr(self, key, None)
+
+    @property
+    def elapsed(self):
+        return int(monotonic() - self.start_ts)
+
+    @property
+    def elapsed_td(self):
+        return timedelta(seconds=self.elapsed)
+
+    def update_avg(self, n, dt):
+        if n > 0:
+            xput_len = len(self._xput)
+            self._xput.append(dt / n)
+            now = monotonic()
+            # update when we're still filling _xput, then after every second
+            if (xput_len < self.sma_window or
+                    now - self._avg_update_ts > 1):
+                self.avg = sum(self._xput) / len(self._xput)
+                self._avg_update_ts = now
+
+    def update(self):
+        pass
+
+    def start(self):
+        pass
+
+    def clearln(self):
+        if self.file and self.is_tty():
+            print('\r\x1b[K', end='', file=self.file)
+
+    def write(self, s):
+        if self.file and self.is_tty():
+            line = self.message + s.ljust(self._width)
+            print('\r' + line, end='', file=self.file)
+            self._width = max(self._width, len(s))
+            self.file.flush()
+
+    def writeln(self, line):
+        if self.file and self.is_tty():
+            self.clearln()
+            print(line, end='', file=self.file)
+            self.file.flush()
+
+    def finish(self):
+        if self.file and self.is_tty():
+            print(file=self.file)
+            if self.hide_cursor:
+                print(SHOW_CURSOR, end='', file=self.file)
+
+    def is_tty(self):
+        return self.file.isatty() if self.check_tty else True
+
+    def next(self, n=1):
+        now = monotonic()
+        dt = now - self._ts
+        self.update_avg(n, dt)
+        self._ts = now
+        self.index = self.index + n
+        self.update()
+
+    def iter(self, it):
+        with self:
+            for x in it:
+                yield x
+                self.next()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.finish()
+
+
+class Progress(Infinite):
+    def __init__(self, *args, **kwargs):
+        super(Progress, self).__init__(*args, **kwargs)
+        self.max = kwargs.get('max', 100)
+
+    @property
+    def eta(self):
+        return int(ceil(self.avg * self.remaining))
+
+    @property
+    def eta_td(self):
+        return timedelta(seconds=self.eta)
+
+    @property
+    def percent(self):
+        return self.progress * 100
+
+    @property
+    def progress(self):
+        return min(1, self.index / self.max)
+
+    @property
+    def remaining(self):
+        return max(self.max - self.index, 0)
+
+    def start(self):
+        self.update()
+
+    def goto(self, index):
+        incr = index - self.index
+        self.next(incr)
+
+    def iter(self, it):
+        try:
+            self.max = len(it)
+        except TypeError:
+            pass
+
+        with self:
+            for x in it:
+                yield x
+                self.next()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/bar.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/bar.py
new file mode 100644
index 0000000000000000000000000000000000000000..8819efda65b9f6bf1315ad15bedc5a3857bf67fc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/bar.py
@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+from __future__ import unicode_literals
+
+import sys
+
+from . import Progress
+
+
+class Bar(Progress):
+    width = 32
+    suffix = '%(index)d/%(max)d'
+    bar_prefix = ' |'
+    bar_suffix = '| '
+    empty_fill = ' '
+    fill = '#'
+
+    def update(self):
+        filled_length = int(self.width * self.progress)
+        empty_length = self.width - filled_length
+
+        message = self.message % self
+        bar = self.fill * filled_length
+        empty = self.empty_fill * empty_length
+        suffix = self.suffix % self
+        line = ''.join([message, self.bar_prefix, bar, empty, self.bar_suffix,
+                        suffix])
+        self.writeln(line)
+
+
+class ChargingBar(Bar):
+    suffix = '%(percent)d%%'
+    bar_prefix = ' '
+    bar_suffix = ' '
+    empty_fill = '∙'
+    fill = '█'
+
+
+class FillingSquaresBar(ChargingBar):
+    empty_fill = '▢'
+    fill = '▣'
+
+
+class FillingCirclesBar(ChargingBar):
+    empty_fill = '◯'
+    fill = '◉'
+
+
+class IncrementalBar(Bar):
+    if sys.platform.startswith('win'):
+        phases = (u' ', u'▌', u'█')
+    else:
+        phases = (' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█')
+
+    def update(self):
+        nphases = len(self.phases)
+        filled_len = self.width * self.progress
+        nfull = int(filled_len)                      # Number of full chars
+        phase = int((filled_len - nfull) * nphases)  # Phase of last char
+        nempty = self.width - nfull                  # Number of empty chars
+
+        message = self.message % self
+        bar = self.phases[-1] * nfull
+        current = self.phases[phase] if phase > 0 else ''
+        empty = self.empty_fill * max(0, nempty - len(current))
+        suffix = self.suffix % self
+        line = ''.join([message, self.bar_prefix, bar, current, empty,
+                        self.bar_suffix, suffix])
+        self.writeln(line)
+
+
+class PixelBar(IncrementalBar):
+    phases = ('⡀', '⡄', '⡆', '⡇', '⣇', '⣧', '⣷', '⣿')
+
+
+class ShadyBar(IncrementalBar):
+    phases = (' ', '░', '▒', '▓', '█')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/counter.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/counter.py
new file mode 100644
index 0000000000000000000000000000000000000000..d955ca4771bb2cd78a8e9334a6917f9f6cce59b1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/counter.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+from __future__ import unicode_literals
+from . import Infinite, Progress
+
+
+class Counter(Infinite):
+    def update(self):
+        self.write(str(self.index))
+
+
+class Countdown(Progress):
+    def update(self):
+        self.write(str(self.remaining))
+
+
+class Stack(Progress):
+    phases = (' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█')
+
+    def update(self):
+        nphases = len(self.phases)
+        i = min(nphases - 1, int(self.progress * nphases))
+        self.write(self.phases[i])
+
+
+class Pie(Stack):
+    phases = ('○', '◔', '◑', '◕', '●')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/spinner.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/spinner.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e100cabb9b8d7113111d1b09a7b84da2895e2a0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/progress/spinner.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+from __future__ import unicode_literals
+from . import Infinite
+
+
+class Spinner(Infinite):
+    phases = ('-', '\\', '|', '/')
+    hide_cursor = True
+
+    def update(self):
+        i = self.index % len(self.phases)
+        self.write(self.phases[i])
+
+
+class PieSpinner(Spinner):
+    phases = ['◷', '◶', '◵', '◴']
+
+
+class MoonSpinner(Spinner):
+    phases = ['◑', '◒', '◐', '◓']
+
+
+class LineSpinner(Spinner):
+    phases = ['⎺', '⎻', '⎼', '⎽', '⎼', '⎻']
+
+
+class PixelSpinner(Spinner):
+    phases = ['⣾', '⣷', '⣯', '⣟', '⡿', '⢿', '⣻', '⣽']
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ed060ff52973e5d9f9faa4afb972ba88beefced
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/__init__.py
@@ -0,0 +1,4 @@
+from .core import TomlError
+from .parser import load, loads
+from .test import translate_to_test
+from .writer import dump, dumps
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/core.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..c182734e1caa00515a06adfb9eab7a22911e658b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/core.py
@@ -0,0 +1,13 @@
+class TomlError(RuntimeError):
+    def __init__(self, message, line, col, filename):
+        RuntimeError.__init__(self, message, line, col, filename)
+        self.message = message
+        self.line = line
+        self.col = col
+        self.filename = filename
+
+    def __str__(self):
+        return '{}({}, {}): {}'.format(self.filename, self.line, self.col, self.message)
+
+    def __repr__(self):
+        return 'TomlError({!r}, {!r}, {!r}, {!r})'.format(self.message, self.line, self.col, self.filename)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/parser.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..3493aa644cac13ab2542f967815593f1690052ec
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/parser.py
@@ -0,0 +1,341 @@
+import string, re, sys, datetime
+from .core import TomlError
+from .utils import rfc3339_re, parse_rfc3339_re
+
+if sys.version_info[0] == 2:
+    _chr = unichr
+else:
+    _chr = chr
+
+def load(fin, translate=lambda t, x, v: v, object_pairs_hook=dict):
+    return loads(fin.read(), translate=translate, object_pairs_hook=object_pairs_hook, filename=getattr(fin, 'name', repr(fin)))
+
+def loads(s, filename='<string>', translate=lambda t, x, v: v, object_pairs_hook=dict):
+    if isinstance(s, bytes):
+        s = s.decode('utf-8')
+
+    s = s.replace('\r\n', '\n')
+
+    root = object_pairs_hook()
+    tables = object_pairs_hook()
+    scope = root
+
+    src = _Source(s, filename=filename)
+    ast = _p_toml(src, object_pairs_hook=object_pairs_hook)
+
+    def error(msg):
+        raise TomlError(msg, pos[0], pos[1], filename)
+
+    def process_value(v, object_pairs_hook):
+        kind, text, value, pos = v
+        if kind == 'str' and value.startswith('\n'):
+            value = value[1:]
+        if kind == 'array':
+            if value and any(k != value[0][0] for k, t, v, p in value[1:]):
+                error('array-type-mismatch')
+            value = [process_value(item, object_pairs_hook=object_pairs_hook) for item in value]
+        elif kind == 'table':
+            value = object_pairs_hook([(k, process_value(value[k], object_pairs_hook=object_pairs_hook)) for k in value])
+        return translate(kind, text, value)
+
+    for kind, value, pos in ast:
+        if kind == 'kv':
+            k, v = value
+            if k in scope:
+                error('duplicate_keys. Key "{0}" was used more than once.'.format(k))
+            scope[k] = process_value(v, object_pairs_hook=object_pairs_hook)
+        else:
+            is_table_array = (kind == 'table_array')
+            cur = tables
+            for name in value[:-1]:
+                if isinstance(cur.get(name), list):
+                    d, cur = cur[name][-1]
+                else:
+                    d, cur = cur.setdefault(name, (None, object_pairs_hook()))
+
+            scope = object_pairs_hook()
+            name = value[-1]
+            if name not in cur:
+                if is_table_array:
+                    cur[name] = [(scope, object_pairs_hook())]
+                else:
+                    cur[name] = (scope, object_pairs_hook())
+            elif isinstance(cur[name], list):
+                if not is_table_array:
+                    error('table_type_mismatch')
+                cur[name].append((scope, object_pairs_hook()))
+            else:
+                if is_table_array:
+                    error('table_type_mismatch')
+                old_scope, next_table = cur[name]
+                if old_scope is not None:
+                    error('duplicate_tables')
+                cur[name] = (scope, next_table)
+
+    def merge_tables(scope, tables):
+        if scope is None:
+            scope = object_pairs_hook()
+        for k in tables:
+            if k in scope:
+                error('key_table_conflict')
+            v = tables[k]
+            if isinstance(v, list):
+                scope[k] = [merge_tables(sc, tbl) for sc, tbl in v]
+            else:
+                scope[k] = merge_tables(v[0], v[1])
+        return scope
+
+    return merge_tables(root, tables)
+
+class _Source:
+    def __init__(self, s, filename=None):
+        self.s = s
+        self._pos = (1, 1)
+        self._last = None
+        self._filename = filename
+        self.backtrack_stack = []
+
+    def last(self):
+        return self._last
+
+    def pos(self):
+        return self._pos
+
+    def fail(self):
+        return self._expect(None)
+
+    def consume_dot(self):
+        if self.s:
+            self._last = self.s[0]
+            self.s = self[1:]
+            self._advance(self._last)
+            return self._last
+        return None
+
+    def expect_dot(self):
+        return self._expect(self.consume_dot())
+
+    def consume_eof(self):
+        if not self.s:
+            self._last = ''
+            return True
+        return False
+
+    def expect_eof(self):
+        return self._expect(self.consume_eof())
+
+    def consume(self, s):
+        if self.s.startswith(s):
+            self.s = self.s[len(s):]
+            self._last = s
+            self._advance(s)
+            return True
+        return False
+
+    def expect(self, s):
+        return self._expect(self.consume(s))
+
+    def consume_re(self, re):
+        m = re.match(self.s)
+        if m:
+            self.s = self.s[len(m.group(0)):]
+            self._last = m
+            self._advance(m.group(0))
+            return m
+        return None
+
+    def expect_re(self, re):
+        return self._expect(self.consume_re(re))
+
+    def __enter__(self):
+        self.backtrack_stack.append((self.s, self._pos))
+
+    def __exit__(self, type, value, traceback):
+        if type is None:
+            self.backtrack_stack.pop()
+        else:
+            self.s, self._pos = self.backtrack_stack.pop()
+        return type == TomlError
+
+    def commit(self):
+        self.backtrack_stack[-1] = (self.s, self._pos)
+
+    def _expect(self, r):
+        if not r:
+            raise TomlError('msg', self._pos[0], self._pos[1], self._filename)
+        return r
+
+    def _advance(self, s):
+        suffix_pos = s.rfind('\n')
+        if suffix_pos == -1:
+            self._pos = (self._pos[0], self._pos[1] + len(s))
+        else:
+            self._pos = (self._pos[0] + s.count('\n'), len(s) - suffix_pos)
+
+_ews_re = re.compile(r'(?:[ \t]|#[^\n]*\n|#[^\n]*\Z|\n)*')
+def _p_ews(s):
+    s.expect_re(_ews_re)
+
+_ws_re = re.compile(r'[ \t]*')
+def _p_ws(s):
+    s.expect_re(_ws_re)
+
+_escapes = { 'b': '\b', 'n': '\n', 'r': '\r', 't': '\t', '"': '"',
+    '\\': '\\', 'f': '\f' }
+
+_basicstr_re = re.compile(r'[^"\\\000-\037]*')
+_short_uni_re = re.compile(r'u([0-9a-fA-F]{4})')
+_long_uni_re = re.compile(r'U([0-9a-fA-F]{8})')
+_escapes_re = re.compile(r'[btnfr\"\\]')
+_newline_esc_re = re.compile('\n[ \t\n]*')
+def _p_basicstr_content(s, content=_basicstr_re):
+    res = []
+    while True:
+        res.append(s.expect_re(content).group(0))
+        if not s.consume('\\'):
+            break
+        if s.consume_re(_newline_esc_re):
+            pass
+        elif s.consume_re(_short_uni_re) or s.consume_re(_long_uni_re):
+            v = int(s.last().group(1), 16)
+            if 0xd800 <= v < 0xe000:
+                s.fail()
+            res.append(_chr(v))
+        else:
+            s.expect_re(_escapes_re)
+            res.append(_escapes[s.last().group(0)])
+    return ''.join(res)
+
+_key_re = re.compile(r'[0-9a-zA-Z-_]+')
+def _p_key(s):
+    with s:
+        s.expect('"')
+        r = _p_basicstr_content(s, _basicstr_re)
+        s.expect('"')
+        return r
+    if s.consume('\''):
+        if s.consume('\'\''):
+            r = s.expect_re(_litstr_ml_re).group(0)
+            s.expect('\'\'\'')
+        else:
+            r = s.expect_re(_litstr_re).group(0)
+            s.expect('\'')
+        return r
+    return s.expect_re(_key_re).group(0)
+
+_float_re = re.compile(r'[+-]?(?:0|[1-9](?:_?\d)*)(?:\.\d(?:_?\d)*)?(?:[eE][+-]?(?:\d(?:_?\d)*))?')
+
+_basicstr_ml_re = re.compile(r'(?:""?(?!")|[^"\\\000-\011\013-\037])*')
+_litstr_re = re.compile(r"[^'\000\010\012-\037]*")
+_litstr_ml_re = re.compile(r"(?:(?:|'|'')(?:[^'\000-\010\013-\037]))*")
+def _p_value(s, object_pairs_hook):
+    pos = s.pos()
+
+    if s.consume('true'):
+        return 'bool', s.last(), True, pos
+    if s.consume('false'):
+        return 'bool', s.last(), False, pos
+
+    if s.consume('"'):
+        if s.consume('""'):
+            r = _p_basicstr_content(s, _basicstr_ml_re)
+            s.expect('"""')
+        else:
+            r = _p_basicstr_content(s, _basicstr_re)
+            s.expect('"')
+        return 'str', r, r, pos
+
+    if s.consume('\''):
+        if s.consume('\'\''):
+            r = s.expect_re(_litstr_ml_re).group(0)
+            s.expect('\'\'\'')
+        else:
+            r = s.expect_re(_litstr_re).group(0)
+            s.expect('\'')
+        return 'str', r, r, pos
+
+    if s.consume_re(rfc3339_re):
+        m = s.last()
+        return 'datetime', m.group(0), parse_rfc3339_re(m), pos
+
+    if s.consume_re(_float_re):
+        m = s.last().group(0)
+        r = m.replace('_','')
+        if '.' in m or 'e' in m or 'E' in m:
+            return 'float', m, float(r), pos
+        else:
+            return 'int', m, int(r, 10), pos
+
+    if s.consume('['):
+        items = []
+        with s:
+            while True:
+                _p_ews(s)
+                items.append(_p_value(s, object_pairs_hook=object_pairs_hook))
+                s.commit()
+                _p_ews(s)
+                s.expect(',')
+                s.commit()
+        _p_ews(s)
+        s.expect(']')
+        return 'array', None, items, pos
+
+    if s.consume('{'):
+        _p_ws(s)
+        items = object_pairs_hook()
+        if not s.consume('}'):
+            k = _p_key(s)
+            _p_ws(s)
+            s.expect('=')
+            _p_ws(s)
+            items[k] = _p_value(s, object_pairs_hook=object_pairs_hook)
+            _p_ws(s)
+            while s.consume(','):
+                _p_ws(s)
+                k = _p_key(s)
+                _p_ws(s)
+                s.expect('=')
+                _p_ws(s)
+                items[k] = _p_value(s, object_pairs_hook=object_pairs_hook)
+                _p_ws(s)
+            s.expect('}')
+        return 'table', None, items, pos
+
+    s.fail()
+
+def _p_stmt(s, object_pairs_hook):
+    pos = s.pos()
+    if s.consume(   '['):
+        is_array = s.consume('[')
+        _p_ws(s)
+        keys = [_p_key(s)]
+        _p_ws(s)
+        while s.consume('.'):
+            _p_ws(s)
+            keys.append(_p_key(s))
+            _p_ws(s)
+        s.expect(']')
+        if is_array:
+            s.expect(']')
+        return 'table_array' if is_array else 'table', keys, pos
+
+    key = _p_key(s)
+    _p_ws(s)
+    s.expect('=')
+    _p_ws(s)
+    value = _p_value(s, object_pairs_hook=object_pairs_hook)
+    return 'kv', (key, value), pos
+
+_stmtsep_re = re.compile(r'(?:[ \t]*(?:#[^\n]*)?\n)+[ \t]*')
+def _p_toml(s, object_pairs_hook):
+    stmts = []
+    _p_ews(s)
+    with s:
+        stmts.append(_p_stmt(s, object_pairs_hook=object_pairs_hook))
+        while True:
+            s.commit()
+            s.expect_re(_stmtsep_re)
+            stmts.append(_p_stmt(s, object_pairs_hook=object_pairs_hook))
+    _p_ews(s)
+    s.expect_eof()
+    return stmts
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/test.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec8abfc650264a5295447da59a242e950d25802d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/test.py
@@ -0,0 +1,30 @@
+import datetime
+from .utils import format_rfc3339
+
+try:
+    _string_types = (str, unicode)
+    _int_types = (int, long)
+except NameError:
+    _string_types = str
+    _int_types = int
+
+def translate_to_test(v):
+    if isinstance(v, dict):
+        return { k: translate_to_test(v) for k, v in v.items() }
+    if isinstance(v, list):
+        a = [translate_to_test(x) for x in v]
+        if v and isinstance(v[0], dict):
+            return a
+        else:
+            return {'type': 'array', 'value': a}
+    if isinstance(v, datetime.datetime):
+        return {'type': 'datetime', 'value': format_rfc3339(v)}
+    if isinstance(v, bool):
+        return {'type': 'bool', 'value': 'true' if v else 'false'}
+    if isinstance(v, _int_types):
+        return {'type': 'integer', 'value': str(v)}
+    if isinstance(v, float):
+        return {'type': 'float', 'value': '{:.17}'.format(v)}
+    if isinstance(v, _string_types):
+        return {'type': 'string', 'value': v}
+    raise RuntimeError('unexpected value: {!r}'.format(v))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/utils.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..636a680b06c48061aa566639372998c6d19551ca
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/utils.py
@@ -0,0 +1,67 @@
+import datetime
+import re
+
+rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')
+
+def parse_rfc3339(v):
+    m = rfc3339_re.match(v)
+    if not m or m.group(0) != v:
+        return None
+    return parse_rfc3339_re(m)
+
+def parse_rfc3339_re(m):
+    r = map(int, m.groups()[:6])
+    if m.group(7):
+        micro = float(m.group(7))
+    else:
+        micro = 0
+
+    if m.group(8):
+        g = int(m.group(8), 10) * 60 + int(m.group(9), 10)
+        tz = _TimeZone(datetime.timedelta(0, g * 60))
+    else:
+        tz = _TimeZone(datetime.timedelta(0, 0))
+
+    y, m, d, H, M, S = r
+    return datetime.datetime(y, m, d, H, M, S, int(micro * 1000000), tz)
+
+
+def format_rfc3339(v):
+    offs = v.utcoffset()
+    offs = int(offs.total_seconds()) // 60 if offs is not None else 0
+
+    if offs == 0:
+        suffix = 'Z'
+    else:
+        if offs > 0:
+            suffix = '+'
+        else:
+            suffix = '-'
+            offs = -offs
+        suffix = '{0}{1:02}:{2:02}'.format(suffix, offs // 60, offs % 60)
+
+    if v.microsecond:
+        return v.strftime('%Y-%m-%dT%H:%M:%S.%f') + suffix
+    else:
+        return v.strftime('%Y-%m-%dT%H:%M:%S') + suffix
+
+class _TimeZone(datetime.tzinfo):
+    def __init__(self, offset):
+        self._offset = offset
+
+    def utcoffset(self, dt):
+        return self._offset
+
+    def dst(self, dt):
+        return None
+
+    def tzname(self, dt):
+        m = self._offset.total_seconds() // 60
+        if m < 0:
+            res = '-'
+            m = -m
+        else:
+            res = '+'
+        h = m // 60
+        m = m - h * 60
+        return '{}{:.02}{:.02}'.format(res, h, m)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/writer.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..73b5089c241ec6a5f94899cda7807c3fc27ed316
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/pytoml/writer.py
@@ -0,0 +1,106 @@
+from __future__ import unicode_literals
+import io, datetime, math, string, sys
+
+from .utils import format_rfc3339
+
+if sys.version_info[0] == 3:
+    long = int
+    unicode = str
+
+
+def dumps(obj, sort_keys=False):
+    fout = io.StringIO()
+    dump(obj, fout, sort_keys=sort_keys)
+    return fout.getvalue()
+
+
+_escapes = {'\n': 'n', '\r': 'r', '\\': '\\', '\t': 't', '\b': 'b', '\f': 'f', '"': '"'}
+
+
+def _escape_string(s):
+    res = []
+    start = 0
+
+    def flush():
+        if start != i:
+            res.append(s[start:i])
+        return i + 1
+
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c in '"\\\n\r\t\b\f':
+            start = flush()
+            res.append('\\' + _escapes[c])
+        elif ord(c) < 0x20:
+            start = flush()
+            res.append('\\u%04x' % ord(c))
+        i += 1
+
+    flush()
+    return '"' + ''.join(res) + '"'
+
+
+_key_chars = string.digits + string.ascii_letters + '-_'
+def _escape_id(s):
+    if any(c not in _key_chars for c in s):
+        return _escape_string(s)
+    return s
+
+
+def _format_value(v):
+    if isinstance(v, bool):
+        return 'true' if v else 'false'
+    if isinstance(v, int) or isinstance(v, long):
+        return unicode(v)
+    if isinstance(v, float):
+        if math.isnan(v) or math.isinf(v):
+            raise ValueError("{0} is not a valid TOML value".format(v))
+        else:
+            return repr(v)
+    elif isinstance(v, unicode) or isinstance(v, bytes):
+        return _escape_string(v)
+    elif isinstance(v, datetime.datetime):
+        return format_rfc3339(v)
+    elif isinstance(v, list):
+        return '[{0}]'.format(', '.join(_format_value(obj) for obj in v))
+    elif isinstance(v, dict):
+        return '{{{0}}}'.format(', '.join('{} = {}'.format(_escape_id(k), _format_value(obj)) for k, obj in v.items()))
+    else:
+        raise RuntimeError(v)
+
+
+def dump(obj, fout, sort_keys=False):
+    tables = [((), obj, False)]
+
+    while tables:
+        name, table, is_array = tables.pop()
+        if name:
+            section_name = '.'.join(_escape_id(c) for c in name)
+            if is_array:
+                fout.write('[[{0}]]\n'.format(section_name))
+            else:
+                fout.write('[{0}]\n'.format(section_name))
+
+        table_keys = sorted(table.keys()) if sort_keys else table.keys()
+        new_tables = []
+        has_kv = False
+        for k in table_keys:
+            v = table[k]
+            if isinstance(v, dict):
+                new_tables.append((name + (k,), v, False))
+            elif isinstance(v, list) and v and all(isinstance(o, dict) for o in v):
+                new_tables.extend((name + (k,), d, True) for d in v)
+            elif v is None:
+                # based on mojombo's comment: https://github.com/toml-lang/toml/issues/146#issuecomment-25019344
+                fout.write(
+                    '#{} = null  # To use: uncomment and replace null with value\n'.format(_escape_id(k)))
+                has_kv = True
+            else:
+                fout.write('{0} = {1}\n'.format(_escape_id(k), _format_value(v)))
+                has_kv = True
+
+        tables.extend(reversed(new_tables))
+
+        if (name or has_kv) and tables:
+            fout.write('\n')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/requests/adapters.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/requests/adapters.py
new file mode 100644
index 0000000000000000000000000000000000000000..c30e7c92dc7f1688c86c345b47656b3561d71373
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/requests/adapters.py
@@ -0,0 +1,533 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.adapters
+~~~~~~~~~~~~~~~~~
+
+This module contains the transport adapters that Requests uses to define
+and maintain connections.
+"""
+
+import os.path
+import socket
+
+from pip._vendor.urllib3.poolmanager import PoolManager, proxy_from_url
+from pip._vendor.urllib3.response import HTTPResponse
+from pip._vendor.urllib3.util import parse_url
+from pip._vendor.urllib3.util import Timeout as TimeoutSauce
+from pip._vendor.urllib3.util.retry import Retry
+from pip._vendor.urllib3.exceptions import ClosedPoolError
+from pip._vendor.urllib3.exceptions import ConnectTimeoutError
+from pip._vendor.urllib3.exceptions import HTTPError as _HTTPError
+from pip._vendor.urllib3.exceptions import MaxRetryError
+from pip._vendor.urllib3.exceptions import NewConnectionError
+from pip._vendor.urllib3.exceptions import ProxyError as _ProxyError
+from pip._vendor.urllib3.exceptions import ProtocolError
+from pip._vendor.urllib3.exceptions import ReadTimeoutError
+from pip._vendor.urllib3.exceptions import SSLError as _SSLError
+from pip._vendor.urllib3.exceptions import ResponseError
+from pip._vendor.urllib3.exceptions import LocationValueError
+
+from .models import Response
+from .compat import urlparse, basestring
+from .utils import (DEFAULT_CA_BUNDLE_PATH, extract_zipped_paths,
+                    get_encoding_from_headers, prepend_scheme_if_needed,
+                    get_auth_from_url, urldefragauth, select_proxy)
+from .structures import CaseInsensitiveDict
+from .cookies import extract_cookies_to_jar
+from .exceptions import (ConnectionError, ConnectTimeout, ReadTimeout, SSLError,
+                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL,
+                         InvalidURL)
+from .auth import _basic_auth_str
+
+try:
+    from pip._vendor.urllib3.contrib.socks import SOCKSProxyManager
+except ImportError:
+    def SOCKSProxyManager(*args, **kwargs):
+        raise InvalidSchema("Missing dependencies for SOCKS support.")
+
+DEFAULT_POOLBLOCK = False
+DEFAULT_POOLSIZE = 10
+DEFAULT_RETRIES = 0
+DEFAULT_POOL_TIMEOUT = None
+
+
+class BaseAdapter(object):
+    """The Base Transport Adapter"""
+
+    def __init__(self):
+        super(BaseAdapter, self).__init__()
+
+    def send(self, request, stream=False, timeout=None, verify=True,
+             cert=None, proxies=None):
+        """Sends PreparedRequest object. Returns Response object.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param stream: (optional) Whether to stream the request content.
+        :param timeout: (optional) How long to wait for the server to send
+            data before giving up, as a float, or a :ref:`(connect timeout,
+            read timeout) <timeouts>` tuple.
+        :type timeout: float or tuple
+        :param verify: (optional) Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use
+        :param cert: (optional) Any user-provided SSL certificate to be trusted.
+        :param proxies: (optional) The proxies dictionary to apply to the request.
+        """
+        raise NotImplementedError
+
+    def close(self):
+        """Cleans up adapter specific items."""
+        raise NotImplementedError
+
+
+class HTTPAdapter(BaseAdapter):
+    """The built-in HTTP Adapter for urllib3.
+
+    Provides a general-case interface for Requests sessions to contact HTTP and
+    HTTPS urls by implementing the Transport Adapter interface. This class will
+    usually be created by the :class:`Session <Session>` class under the
+    covers.
+
+    :param pool_connections: The number of urllib3 connection pools to cache.
+    :param pool_maxsize: The maximum number of connections to save in the pool.
+    :param max_retries: The maximum number of retries each connection
+        should attempt. Note, this applies only to failed DNS lookups, socket
+        connections and connection timeouts, never to requests where data has
+        made it to the server. By default, Requests does not retry failed
+        connections. If you need granular control over the conditions under
+        which we retry a request, import urllib3's ``Retry`` class and pass
+        that instead.
+    :param pool_block: Whether the connection pool should block for connections.
+
+    Usage::
+
+      >>> import requests
+      >>> s = requests.Session()
+      >>> a = requests.adapters.HTTPAdapter(max_retries=3)
+      >>> s.mount('http://', a)
+    """
+    __attrs__ = ['max_retries', 'config', '_pool_connections', '_pool_maxsize',
+                 '_pool_block']
+
+    def __init__(self, pool_connections=DEFAULT_POOLSIZE,
+                 pool_maxsize=DEFAULT_POOLSIZE, max_retries=DEFAULT_RETRIES,
+                 pool_block=DEFAULT_POOLBLOCK):
+        if max_retries == DEFAULT_RETRIES:
+            self.max_retries = Retry(0, read=False)
+        else:
+            self.max_retries = Retry.from_int(max_retries)
+        self.config = {}
+        self.proxy_manager = {}
+
+        super(HTTPAdapter, self).__init__()
+
+        self._pool_connections = pool_connections
+        self._pool_maxsize = pool_maxsize
+        self._pool_block = pool_block
+
+        self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
+
+    def __getstate__(self):
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
+
+    def __setstate__(self, state):
+        # Can't handle by adding 'proxy_manager' to self.__attrs__ because
+        # self.poolmanager uses a lambda function, which isn't pickleable.
+        self.proxy_manager = {}
+        self.config = {}
+
+        for attr, value in state.items():
+            setattr(self, attr, value)
+
+        self.init_poolmanager(self._pool_connections, self._pool_maxsize,
+                              block=self._pool_block)
+
+    def init_poolmanager(self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs):
+        """Initializes a urllib3 PoolManager.
+
+        This method should not be called from user code, and is only
+        exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param connections: The number of urllib3 connection pools to cache.
+        :param maxsize: The maximum number of connections to save in the pool.
+        :param block: Block when no free connections are available.
+        :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
+        """
+        # save these values for pickling
+        self._pool_connections = connections
+        self._pool_maxsize = maxsize
+        self._pool_block = block
+
+        self.poolmanager = PoolManager(num_pools=connections, maxsize=maxsize,
+                                       block=block, strict=True, **pool_kwargs)
+
+    def proxy_manager_for(self, proxy, **proxy_kwargs):
+        """Return urllib3 ProxyManager for the given proxy.
+
+        This method should not be called from user code, and is only
+        exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param proxy: The proxy to return a urllib3 ProxyManager for.
+        :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
+        :returns: ProxyManager
+        :rtype: urllib3.ProxyManager
+        """
+        if proxy in self.proxy_manager:
+            manager = self.proxy_manager[proxy]
+        elif proxy.lower().startswith('socks'):
+            username, password = get_auth_from_url(proxy)
+            manager = self.proxy_manager[proxy] = SOCKSProxyManager(
+                proxy,
+                username=username,
+                password=password,
+                num_pools=self._pool_connections,
+                maxsize=self._pool_maxsize,
+                block=self._pool_block,
+                **proxy_kwargs
+            )
+        else:
+            proxy_headers = self.proxy_headers(proxy)
+            manager = self.proxy_manager[proxy] = proxy_from_url(
+                proxy,
+                proxy_headers=proxy_headers,
+                num_pools=self._pool_connections,
+                maxsize=self._pool_maxsize,
+                block=self._pool_block,
+                **proxy_kwargs)
+
+        return manager
+
+    def cert_verify(self, conn, url, verify, cert):
+        """Verify a SSL certificate. This method should not be called from user
+        code, and is only exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param conn: The urllib3 connection object associated with the cert.
+        :param url: The requested URL.
+        :param verify: Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use
+        :param cert: The SSL certificate to verify.
+        """
+        if url.lower().startswith('https') and verify:
+
+            cert_loc = None
+
+            # Allow self-specified cert location.
+            if verify is not True:
+                cert_loc = verify
+
+            if not cert_loc:
+                cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
+
+            if not cert_loc or not os.path.exists(cert_loc):
+                raise IOError("Could not find a suitable TLS CA certificate bundle, "
+                              "invalid path: {}".format(cert_loc))
+
+            conn.cert_reqs = 'CERT_REQUIRED'
+
+            if not os.path.isdir(cert_loc):
+                conn.ca_certs = cert_loc
+            else:
+                conn.ca_cert_dir = cert_loc
+        else:
+            conn.cert_reqs = 'CERT_NONE'
+            conn.ca_certs = None
+            conn.ca_cert_dir = None
+
+        if cert:
+            if not isinstance(cert, basestring):
+                conn.cert_file = cert[0]
+                conn.key_file = cert[1]
+            else:
+                conn.cert_file = cert
+                conn.key_file = None
+            if conn.cert_file and not os.path.exists(conn.cert_file):
+                raise IOError("Could not find the TLS certificate file, "
+                              "invalid path: {}".format(conn.cert_file))
+            if conn.key_file and not os.path.exists(conn.key_file):
+                raise IOError("Could not find the TLS key file, "
+                              "invalid path: {}".format(conn.key_file))
+
+    def build_response(self, req, resp):
+        """Builds a :class:`Response <requests.Response>` object from a urllib3
+        response. This should not be called from user code, and is only exposed
+        for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`
+
+        :param req: The :class:`PreparedRequest <PreparedRequest>` used to generate the response.
+        :param resp: The urllib3 response object.
+        :rtype: requests.Response
+        """
+        response = Response()
+
+        # Fallback to None if there's no status_code, for whatever reason.
+        response.status_code = getattr(resp, 'status', None)
+
+        # Make headers case-insensitive.
+        response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {}))
+
+        # Set encoding.
+        response.encoding = get_encoding_from_headers(response.headers)
+        response.raw = resp
+        response.reason = response.raw.reason
+
+        if isinstance(req.url, bytes):
+            response.url = req.url.decode('utf-8')
+        else:
+            response.url = req.url
+
+        # Add new cookies from the server.
+        extract_cookies_to_jar(response.cookies, req, resp)
+
+        # Give the Response some context.
+        response.request = req
+        response.connection = self
+
+        return response
+
+    def get_connection(self, url, proxies=None):
+        """Returns a urllib3 connection for the given URL. This should not be
+        called from user code, and is only exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param url: The URL to connect to.
+        :param proxies: (optional) A Requests-style dictionary of proxies used on this request.
+        :rtype: urllib3.ConnectionPool
+        """
+        proxy = select_proxy(url, proxies)
+
+        if proxy:
+            proxy = prepend_scheme_if_needed(proxy, 'http')
+            proxy_url = parse_url(proxy)
+            if not proxy_url.host:
+                raise InvalidProxyURL("Please check proxy URL. It is malformed"
+                                      " and could be missing the host.")
+            proxy_manager = self.proxy_manager_for(proxy)
+            conn = proxy_manager.connection_from_url(url)
+        else:
+            # Only scheme should be lower case
+            parsed = urlparse(url)
+            url = parsed.geturl()
+            conn = self.poolmanager.connection_from_url(url)
+
+        return conn
+
+    def close(self):
+        """Disposes of any internal state.
+
+        Currently, this closes the PoolManager and any active ProxyManager,
+        which closes any pooled connections.
+        """
+        self.poolmanager.clear()
+        for proxy in self.proxy_manager.values():
+            proxy.clear()
+
+    def request_url(self, request, proxies):
+        """Obtain the url to use when making the final request.
+
+        If the message is being sent through a HTTP proxy, the full URL has to
+        be used. Otherwise, we should only use the path portion of the URL.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
+        :rtype: str
+        """
+        proxy = select_proxy(request.url, proxies)
+        scheme = urlparse(request.url).scheme
+
+        is_proxied_http_request = (proxy and scheme != 'https')
+        using_socks_proxy = False
+        if proxy:
+            proxy_scheme = urlparse(proxy).scheme.lower()
+            using_socks_proxy = proxy_scheme.startswith('socks')
+
+        url = request.path_url
+        if is_proxied_http_request and not using_socks_proxy:
+            url = urldefragauth(request.url)
+
+        return url
+
+    def add_headers(self, request, **kwargs):
+        """Add any headers needed by the connection. As of v2.0 this does
+        nothing by default, but is left for overriding by users that subclass
+        the :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` to add headers to.
+        :param kwargs: The keyword arguments from the call to send().
+        """
+        pass
+
+    def proxy_headers(self, proxy):
+        """Returns a dictionary of the headers to add to any request sent
+        through a proxy. This works with urllib3 magic to ensure that they are
+        correctly sent to the proxy, rather than in a tunnelled request if
+        CONNECT is being used.
+
+        This should not be called from user code, and is only exposed for use
+        when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param proxy: The url of the proxy being used for this request.
+        :rtype: dict
+        """
+        headers = {}
+        username, password = get_auth_from_url(proxy)
+
+        if username:
+            headers['Proxy-Authorization'] = _basic_auth_str(username,
+                                                             password)
+
+        return headers
+
+    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
+        """Sends PreparedRequest object. Returns Response object.
+
+        :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
+        :param stream: (optional) Whether to stream the request content.
+        :param timeout: (optional) How long to wait for the server to send
+            data before giving up, as a float, or a :ref:`(connect timeout,
+            read timeout) <timeouts>` tuple.
+        :type timeout: float or tuple or urllib3 Timeout object
+        :param verify: (optional) Either a boolean, in which case it controls whether
+            we verify the server's TLS certificate, or a string, in which case it
+            must be a path to a CA bundle to use
+        :param cert: (optional) Any user-provided SSL certificate to be trusted.
+        :param proxies: (optional) The proxies dictionary to apply to the request.
+        :rtype: requests.Response
+        """
+
+        try:
+            conn = self.get_connection(request.url, proxies)
+        except LocationValueError as e:
+            raise InvalidURL(e, request=request)
+
+        self.cert_verify(conn, request.url, verify, cert)
+        url = self.request_url(request, proxies)
+        self.add_headers(request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies)
+
+        chunked = not (request.body is None or 'Content-Length' in request.headers)
+
+        if isinstance(timeout, tuple):
+            try:
+                connect, read = timeout
+                timeout = TimeoutSauce(connect=connect, read=read)
+            except ValueError as e:
+                # this may raise a string formatting error.
+                err = ("Invalid timeout {}. Pass a (connect, read) "
+                       "timeout tuple, or a single float to set "
+                       "both timeouts to the same value".format(timeout))
+                raise ValueError(err)
+        elif isinstance(timeout, TimeoutSauce):
+            pass
+        else:
+            timeout = TimeoutSauce(connect=timeout, read=timeout)
+
+        try:
+            if not chunked:
+                resp = conn.urlopen(
+                    method=request.method,
+                    url=url,
+                    body=request.body,
+                    headers=request.headers,
+                    redirect=False,
+                    assert_same_host=False,
+                    preload_content=False,
+                    decode_content=False,
+                    retries=self.max_retries,
+                    timeout=timeout
+                )
+
+            # Send the request.
+            else:
+                if hasattr(conn, 'proxy_pool'):
+                    conn = conn.proxy_pool
+
+                low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)
+
+                try:
+                    low_conn.putrequest(request.method,
+                                        url,
+                                        skip_accept_encoding=True)
+
+                    for header, value in request.headers.items():
+                        low_conn.putheader(header, value)
+
+                    low_conn.endheaders()
+
+                    for i in request.body:
+                        low_conn.send(hex(len(i))[2:].encode('utf-8'))
+                        low_conn.send(b'\r\n')
+                        low_conn.send(i)
+                        low_conn.send(b'\r\n')
+                    low_conn.send(b'0\r\n\r\n')
+
+                    # Receive the response from the server
+                    try:
+                        # For Python 2.7, use buffering of HTTP responses
+                        r = low_conn.getresponse(buffering=True)
+                    except TypeError:
+                        # For compatibility with Python 3.3+
+                        r = low_conn.getresponse()
+
+                    resp = HTTPResponse.from_httplib(
+                        r,
+                        pool=conn,
+                        connection=low_conn,
+                        preload_content=False,
+                        decode_content=False
+                    )
+                except:
+                    # If we hit any problems here, clean up the connection.
+                    # Then, reraise so that we can handle the actual exception.
+                    low_conn.close()
+                    raise
+
+        except (ProtocolError, socket.error) as err:
+            raise ConnectionError(err, request=request)
+
+        except MaxRetryError as e:
+            if isinstance(e.reason, ConnectTimeoutError):
+                # TODO: Remove this in 3.0.0: see #2811
+                if not isinstance(e.reason, NewConnectionError):
+                    raise ConnectTimeout(e, request=request)
+
+            if isinstance(e.reason, ResponseError):
+                raise RetryError(e, request=request)
+
+            if isinstance(e.reason, _ProxyError):
+                raise ProxyError(e, request=request)
+
+            if isinstance(e.reason, _SSLError):
+                # This branch is for urllib3 v1.22 and later.
+                raise SSLError(e, request=request)
+
+            raise ConnectionError(e, request=request)
+
+        except ClosedPoolError as e:
+            raise ConnectionError(e, request=request)
+
+        except _ProxyError as e:
+            raise ProxyError(e)
+
+        except (_SSLError, _HTTPError) as e:
+            if isinstance(e, _SSLError):
+                # This branch is for urllib3 versions earlier than v1.22
+                raise SSLError(e, request=request)
+            elif isinstance(e, ReadTimeoutError):
+                raise ReadTimeout(e, request=request)
+            else:
+                raise
+
+        return self.build_response(request, resp)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4c0dde54ab0e266fd290b7fc6d79b39b49a4656
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/__init__.py
@@ -0,0 +1,91 @@
+"""
+urllib3 - Thread-safe connection pooling and re-using.
+"""
+from __future__ import absolute_import
+import warnings
+
+from .connectionpool import (
+    HTTPConnectionPool,
+    HTTPSConnectionPool,
+    connection_from_url
+)
+
+from . import exceptions
+from .filepost import encode_multipart_formdata
+from .poolmanager import PoolManager, ProxyManager, proxy_from_url
+from .response import HTTPResponse
+from .util.request import make_headers
+from .util.url import get_host
+from .util.timeout import Timeout
+from .util.retry import Retry
+
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+from logging import NullHandler
+
+__author__ = 'Andrey Petrov (andrey.petrov@shazow.net)'
+__license__ = 'MIT'
+__version__ = '1.25.3'
+
+__all__ = (
+    'HTTPConnectionPool',
+    'HTTPSConnectionPool',
+    'PoolManager',
+    'ProxyManager',
+    'HTTPResponse',
+    'Retry',
+    'Timeout',
+    'add_stderr_logger',
+    'connection_from_url',
+    'disable_warnings',
+    'encode_multipart_formdata',
+    'get_host',
+    'make_headers',
+    'proxy_from_url',
+)
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+def add_stderr_logger(level=logging.DEBUG):
+    """
+    Helper for quickly adding a StreamHandler to the logger. Useful for
+    debugging.
+
+    Returns the handler after adding it.
+    """
+    # This method needs to be in this __init__.py to get the __name__ correct
+    # even if urllib3 is vendored within another package.
+    logger = logging.getLogger(__name__)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    logger.debug('Added a stderr logging handler to logger: %s', __name__)
+    return handler
+
+
+# ... Clean up.
+del NullHandler
+
+
+# All warning filters *must* be appended unless you're really certain that they
+# shouldn't be: otherwise, it's very hard for users to use most Python
+# mechanisms to silence them.
+# SecurityWarning's always go off by default.
+warnings.simplefilter('always', exceptions.SecurityWarning, append=True)
+# SubjectAltNameWarning's should go off once per host
+warnings.simplefilter('default', exceptions.SubjectAltNameWarning, append=True)
+# InsecurePlatformWarning's don't vary between requests, so we keep it default.
+warnings.simplefilter('default', exceptions.InsecurePlatformWarning,
+                      append=True)
+# SNIMissingWarnings should go off only once.
+warnings.simplefilter('default', exceptions.SNIMissingWarning, append=True)
+
+
+def disable_warnings(category=exceptions.HTTPWarning):
+    """
+    Helper for quickly disabling all urllib3 warnings.
+    """
+    warnings.simplefilter('ignore', category)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/_collections.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/_collections.py
new file mode 100644
index 0000000000000000000000000000000000000000..34f23811c627d22254152a456c8636302e056ff9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/_collections.py
@@ -0,0 +1,329 @@
+from __future__ import absolute_import
+try:
+    from collections.abc import Mapping, MutableMapping
+except ImportError:
+    from collections import Mapping, MutableMapping
+try:
+    from threading import RLock
+except ImportError:  # Platform-specific: No threads available
+    class RLock:
+        def __enter__(self):
+            pass
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+
+from collections import OrderedDict
+from .exceptions import InvalidHeader
+from .packages.six import iterkeys, itervalues, PY3
+
+
+__all__ = ['RecentlyUsedContainer', 'HTTPHeaderDict']
+
+
+_Null = object()
+
+
+class RecentlyUsedContainer(MutableMapping):
+    """
+    Provides a thread-safe dict-like container which maintains up to
+    ``maxsize`` keys while throwing away the least-recently-used keys beyond
+    ``maxsize``.
+
+    :param maxsize:
+        Maximum number of recent elements to retain.
+
+    :param dispose_func:
+        Every time an item is evicted from the container,
+        ``dispose_func(value)`` is called.  Callback which will get called
+    """
+
+    ContainerCls = OrderedDict
+
+    def __init__(self, maxsize=10, dispose_func=None):
+        self._maxsize = maxsize
+        self.dispose_func = dispose_func
+
+        self._container = self.ContainerCls()
+        self.lock = RLock()
+
+    def __getitem__(self, key):
+        # Re-insert the item, moving it to the end of the eviction line.
+        with self.lock:
+            item = self._container.pop(key)
+            self._container[key] = item
+            return item
+
+    def __setitem__(self, key, value):
+        evicted_value = _Null
+        with self.lock:
+            # Possibly evict the existing value of 'key'
+            evicted_value = self._container.get(key, _Null)
+            self._container[key] = value
+
+            # If we didn't evict an existing value, we might have to evict the
+            # least recently used item from the beginning of the container.
+            if len(self._container) > self._maxsize:
+                _key, evicted_value = self._container.popitem(last=False)
+
+        if self.dispose_func and evicted_value is not _Null:
+            self.dispose_func(evicted_value)
+
+    def __delitem__(self, key):
+        with self.lock:
+            value = self._container.pop(key)
+
+        if self.dispose_func:
+            self.dispose_func(value)
+
+    def __len__(self):
+        with self.lock:
+            return len(self._container)
+
+    def __iter__(self):
+        raise NotImplementedError('Iteration over this class is unlikely to be threadsafe.')
+
+    def clear(self):
+        with self.lock:
+            # Copy pointers to all values, then wipe the mapping
+            values = list(itervalues(self._container))
+            self._container.clear()
+
+        if self.dispose_func:
+            for value in values:
+                self.dispose_func(value)
+
+    def keys(self):
+        with self.lock:
+            return list(iterkeys(self._container))
+
+
+class HTTPHeaderDict(MutableMapping):
+    """
+    :param headers:
+        An iterable of field-value pairs. Must not contain multiple field names
+        when compared case-insensitively.
+
+    :param kwargs:
+        Additional field-value pairs to pass in to ``dict.update``.
+
+    A ``dict`` like container for storing HTTP Headers.
+
+    Field names are stored and compared case-insensitively in compliance with
+    RFC 7230. Iteration provides the first case-sensitive key seen for each
+    case-insensitive pair.
+
+    Using ``__setitem__`` syntax overwrites fields that compare equal
+    case-insensitively in order to maintain ``dict``'s api. For fields that
+    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
+    in a loop.
+
+    If multiple fields that are equal case-insensitively are passed to the
+    constructor or ``.update``, the behavior is undefined and some will be
+    lost.
+
+    >>> headers = HTTPHeaderDict()
+    >>> headers.add('Set-Cookie', 'foo=bar')
+    >>> headers.add('set-cookie', 'baz=quxx')
+    >>> headers['content-length'] = '7'
+    >>> headers['SET-cookie']
+    'foo=bar, baz=quxx'
+    >>> headers['Content-Length']
+    '7'
+    """
+
+    def __init__(self, headers=None, **kwargs):
+        super(HTTPHeaderDict, self).__init__()
+        self._container = OrderedDict()
+        if headers is not None:
+            if isinstance(headers, HTTPHeaderDict):
+                self._copy_from(headers)
+            else:
+                self.extend(headers)
+        if kwargs:
+            self.extend(kwargs)
+
+    def __setitem__(self, key, val):
+        self._container[key.lower()] = [key, val]
+        return self._container[key.lower()]
+
+    def __getitem__(self, key):
+        val = self._container[key.lower()]
+        return ', '.join(val[1:])
+
+    def __delitem__(self, key):
+        del self._container[key.lower()]
+
+    def __contains__(self, key):
+        return key.lower() in self._container
+
+    def __eq__(self, other):
+        if not isinstance(other, Mapping) and not hasattr(other, 'keys'):
+            return False
+        if not isinstance(other, type(self)):
+            other = type(self)(other)
+        return (dict((k.lower(), v) for k, v in self.itermerged()) ==
+                dict((k.lower(), v) for k, v in other.itermerged()))
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    if not PY3:  # Python 2
+        iterkeys = MutableMapping.iterkeys
+        itervalues = MutableMapping.itervalues
+
+    __marker = object()
+
+    def __len__(self):
+        return len(self._container)
+
+    def __iter__(self):
+        # Only provide the originally cased names
+        for vals in self._container.values():
+            yield vals[0]
+
+    def pop(self, key, default=__marker):
+        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+          If key is not found, d is returned if given, otherwise KeyError is raised.
+        '''
+        # Using the MutableMapping function directly fails due to the private marker.
+        # Using ordinary dict.pop would expose the internal structures.
+        # So let's reinvent the wheel.
+        try:
+            value = self[key]
+        except KeyError:
+            if default is self.__marker:
+                raise
+            return default
+        else:
+            del self[key]
+            return value
+
+    def discard(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            pass
+
+    def add(self, key, val):
+        """Adds a (name, value) pair, doesn't overwrite the value if it already
+        exists.
+
+        >>> headers = HTTPHeaderDict(foo='bar')
+        >>> headers.add('Foo', 'baz')
+        >>> headers['foo']
+        'bar, baz'
+        """
+        key_lower = key.lower()
+        new_vals = [key, val]
+        # Keep the common case aka no item present as fast as possible
+        vals = self._container.setdefault(key_lower, new_vals)
+        if new_vals is not vals:
+            vals.append(val)
+
+    def extend(self, *args, **kwargs):
+        """Generic import function for any type of header-like object.
+        Adapted version of MutableMapping.update in order to insert items
+        with self.add instead of self.__setitem__
+        """
+        if len(args) > 1:
+            raise TypeError("extend() takes at most 1 positional "
+                            "arguments ({0} given)".format(len(args)))
+        other = args[0] if len(args) >= 1 else ()
+
+        if isinstance(other, HTTPHeaderDict):
+            for key, val in other.iteritems():
+                self.add(key, val)
+        elif isinstance(other, Mapping):
+            for key in other:
+                self.add(key, other[key])
+        elif hasattr(other, "keys"):
+            for key in other.keys():
+                self.add(key, other[key])
+        else:
+            for key, value in other:
+                self.add(key, value)
+
+        for key, value in kwargs.items():
+            self.add(key, value)
+
+    def getlist(self, key, default=__marker):
+        """Returns a list of all the values for the named field. Returns an
+        empty list if the key doesn't exist."""
+        try:
+            vals = self._container[key.lower()]
+        except KeyError:
+            if default is self.__marker:
+                return []
+            return default
+        else:
+            return vals[1:]
+
+    # Backwards compatibility for httplib
+    getheaders = getlist
+    getallmatchingheaders = getlist
+    iget = getlist
+
+    # Backwards compatibility for http.cookiejar
+    get_all = getlist
+
+    def __repr__(self):
+        return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
+
+    def _copy_from(self, other):
+        for key in other:
+            val = other.getlist(key)
+            if isinstance(val, list):
+                # Don't need to convert tuples
+                val = list(val)
+            self._container[key.lower()] = [key] + val
+
+    def copy(self):
+        clone = type(self)()
+        clone._copy_from(self)
+        return clone
+
+    def iteritems(self):
+        """Iterate over all header lines, including duplicate ones."""
+        for key in self:
+            vals = self._container[key.lower()]
+            for val in vals[1:]:
+                yield vals[0], val
+
+    def itermerged(self):
+        """Iterate over all headers, merging duplicate ones together."""
+        for key in self:
+            val = self._container[key.lower()]
+            yield val[0], ', '.join(val[1:])
+
+    def items(self):
+        return list(self.iteritems())
+
+    @classmethod
+    def from_httplib(cls, message):  # Python 2
+        """Read headers from a Python 2 httplib message object."""
+        # python2.7 does not expose a proper API for exporting multiheaders
+        # efficiently. This function re-reads raw lines from the message
+        # object and extracts the multiheaders properly.
+        obs_fold_continued_leaders = (' ', '\t')
+        headers = []
+
+        for line in message.headers:
+            if line.startswith(obs_fold_continued_leaders):
+                if not headers:
+                    # We received a header line that starts with OWS as described
+                    # in RFC-7230 S3.2.4. This indicates a multiline header, but
+                    # there exists no previous header to which we can attach it.
+                    raise InvalidHeader(
+                        'Header continuation with no previous header: %s' % line
+                    )
+                else:
+                    key, value = headers[-1]
+                    headers[-1] = (key, value + ' ' + line.strip())
+                    continue
+
+            key, value = line.split(':', 1)
+            headers.append((key, value.strip()))
+
+        return cls(headers)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3e00942cb9f9d6c6a179b1b06f2df07b7b8463c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_appengine_environ.py
@@ -0,0 +1,30 @@
+"""
+This module provides means to detect the App Engine environment.
+"""
+
+import os
+
+
+def is_appengine():
+    return (is_local_appengine() or
+            is_prod_appengine() or
+            is_prod_appengine_mvms())
+
+
+def is_appengine_sandbox():
+    return is_appengine() and not is_prod_appengine_mvms()
+
+
+def is_local_appengine():
+    return ('APPENGINE_RUNTIME' in os.environ and
+            'Development/' in os.environ['SERVER_SOFTWARE'])
+
+
+def is_prod_appengine():
+    return ('APPENGINE_RUNTIME' in os.environ and
+            'Google App Engine/' in os.environ['SERVER_SOFTWARE'] and
+            not is_prod_appengine_mvms())
+
+
+def is_prod_appengine_mvms():
+    return os.environ.get('GAE_VM', False) == 'true'
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
new file mode 100644
index 0000000000000000000000000000000000000000..be3421535907e012aca5de39baf3c06e523fed21
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/bindings.py
@@ -0,0 +1,593 @@
+"""
+This module uses ctypes to bind a whole bunch of functions and constants from
+SecureTransport. The goal here is to provide the low-level API to
+SecureTransport. These are essentially the C-level functions and constants, and
+they're pretty gross to work with.
+
+This code is a bastardised version of the code found in Will Bond's oscrypto
+library. An enormous debt is owed to him for blazing this trail for us. For
+that reason, this code should be considered to be covered both by urllib3's
+license and by oscrypto's:
+
+    Copyright (c) 2015-2016 Will Bond <will@wbond.net>
+
+    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.
+"""
+from __future__ import absolute_import
+
+import platform
+from ctypes.util import find_library
+from ctypes import (
+    c_void_p, c_int32, c_char_p, c_size_t, c_byte, c_uint32, c_ulong, c_long,
+    c_bool
+)
+from ctypes import CDLL, POINTER, CFUNCTYPE
+
+
+security_path = find_library('Security')
+if not security_path:
+    raise ImportError('The library Security could not be found')
+
+
+core_foundation_path = find_library('CoreFoundation')
+if not core_foundation_path:
+    raise ImportError('The library CoreFoundation could not be found')
+
+
+version = platform.mac_ver()[0]
+version_info = tuple(map(int, version.split('.')))
+if version_info < (10, 8):
+    raise OSError(
+        'Only OS X 10.8 and newer are supported, not %s.%s' % (
+            version_info[0], version_info[1]
+        )
+    )
+
+Security = CDLL(security_path, use_errno=True)
+CoreFoundation = CDLL(core_foundation_path, use_errno=True)
+
+Boolean = c_bool
+CFIndex = c_long
+CFStringEncoding = c_uint32
+CFData = c_void_p
+CFString = c_void_p
+CFArray = c_void_p
+CFMutableArray = c_void_p
+CFDictionary = c_void_p
+CFError = c_void_p
+CFType = c_void_p
+CFTypeID = c_ulong
+
+CFTypeRef = POINTER(CFType)
+CFAllocatorRef = c_void_p
+
+OSStatus = c_int32
+
+CFDataRef = POINTER(CFData)
+CFStringRef = POINTER(CFString)
+CFArrayRef = POINTER(CFArray)
+CFMutableArrayRef = POINTER(CFMutableArray)
+CFDictionaryRef = POINTER(CFDictionary)
+CFArrayCallBacks = c_void_p
+CFDictionaryKeyCallBacks = c_void_p
+CFDictionaryValueCallBacks = c_void_p
+
+SecCertificateRef = POINTER(c_void_p)
+SecExternalFormat = c_uint32
+SecExternalItemType = c_uint32
+SecIdentityRef = POINTER(c_void_p)
+SecItemImportExportFlags = c_uint32
+SecItemImportExportKeyParameters = c_void_p
+SecKeychainRef = POINTER(c_void_p)
+SSLProtocol = c_uint32
+SSLCipherSuite = c_uint32
+SSLContextRef = POINTER(c_void_p)
+SecTrustRef = POINTER(c_void_p)
+SSLConnectionRef = c_uint32
+SecTrustResultType = c_uint32
+SecTrustOptionFlags = c_uint32
+SSLProtocolSide = c_uint32
+SSLConnectionType = c_uint32
+SSLSessionOption = c_uint32
+
+
+try:
+    Security.SecItemImport.argtypes = [
+        CFDataRef,
+        CFStringRef,
+        POINTER(SecExternalFormat),
+        POINTER(SecExternalItemType),
+        SecItemImportExportFlags,
+        POINTER(SecItemImportExportKeyParameters),
+        SecKeychainRef,
+        POINTER(CFArrayRef),
+    ]
+    Security.SecItemImport.restype = OSStatus
+
+    Security.SecCertificateGetTypeID.argtypes = []
+    Security.SecCertificateGetTypeID.restype = CFTypeID
+
+    Security.SecIdentityGetTypeID.argtypes = []
+    Security.SecIdentityGetTypeID.restype = CFTypeID
+
+    Security.SecKeyGetTypeID.argtypes = []
+    Security.SecKeyGetTypeID.restype = CFTypeID
+
+    Security.SecCertificateCreateWithData.argtypes = [
+        CFAllocatorRef,
+        CFDataRef
+    ]
+    Security.SecCertificateCreateWithData.restype = SecCertificateRef
+
+    Security.SecCertificateCopyData.argtypes = [
+        SecCertificateRef
+    ]
+    Security.SecCertificateCopyData.restype = CFDataRef
+
+    Security.SecCopyErrorMessageString.argtypes = [
+        OSStatus,
+        c_void_p
+    ]
+    Security.SecCopyErrorMessageString.restype = CFStringRef
+
+    Security.SecIdentityCreateWithCertificate.argtypes = [
+        CFTypeRef,
+        SecCertificateRef,
+        POINTER(SecIdentityRef)
+    ]
+    Security.SecIdentityCreateWithCertificate.restype = OSStatus
+
+    Security.SecKeychainCreate.argtypes = [
+        c_char_p,
+        c_uint32,
+        c_void_p,
+        Boolean,
+        c_void_p,
+        POINTER(SecKeychainRef)
+    ]
+    Security.SecKeychainCreate.restype = OSStatus
+
+    Security.SecKeychainDelete.argtypes = [
+        SecKeychainRef
+    ]
+    Security.SecKeychainDelete.restype = OSStatus
+
+    Security.SecPKCS12Import.argtypes = [
+        CFDataRef,
+        CFDictionaryRef,
+        POINTER(CFArrayRef)
+    ]
+    Security.SecPKCS12Import.restype = OSStatus
+
+    SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t))
+    SSLWriteFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t))
+
+    Security.SSLSetIOFuncs.argtypes = [
+        SSLContextRef,
+        SSLReadFunc,
+        SSLWriteFunc
+    ]
+    Security.SSLSetIOFuncs.restype = OSStatus
+
+    Security.SSLSetPeerID.argtypes = [
+        SSLContextRef,
+        c_char_p,
+        c_size_t
+    ]
+    Security.SSLSetPeerID.restype = OSStatus
+
+    Security.SSLSetCertificate.argtypes = [
+        SSLContextRef,
+        CFArrayRef
+    ]
+    Security.SSLSetCertificate.restype = OSStatus
+
+    Security.SSLSetCertificateAuthorities.argtypes = [
+        SSLContextRef,
+        CFTypeRef,
+        Boolean
+    ]
+    Security.SSLSetCertificateAuthorities.restype = OSStatus
+
+    Security.SSLSetConnection.argtypes = [
+        SSLContextRef,
+        SSLConnectionRef
+    ]
+    Security.SSLSetConnection.restype = OSStatus
+
+    Security.SSLSetPeerDomainName.argtypes = [
+        SSLContextRef,
+        c_char_p,
+        c_size_t
+    ]
+    Security.SSLSetPeerDomainName.restype = OSStatus
+
+    Security.SSLHandshake.argtypes = [
+        SSLContextRef
+    ]
+    Security.SSLHandshake.restype = OSStatus
+
+    Security.SSLRead.argtypes = [
+        SSLContextRef,
+        c_char_p,
+        c_size_t,
+        POINTER(c_size_t)
+    ]
+    Security.SSLRead.restype = OSStatus
+
+    Security.SSLWrite.argtypes = [
+        SSLContextRef,
+        c_char_p,
+        c_size_t,
+        POINTER(c_size_t)
+    ]
+    Security.SSLWrite.restype = OSStatus
+
+    Security.SSLClose.argtypes = [
+        SSLContextRef
+    ]
+    Security.SSLClose.restype = OSStatus
+
+    Security.SSLGetNumberSupportedCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(c_size_t)
+    ]
+    Security.SSLGetNumberSupportedCiphers.restype = OSStatus
+
+    Security.SSLGetSupportedCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        POINTER(c_size_t)
+    ]
+    Security.SSLGetSupportedCiphers.restype = OSStatus
+
+    Security.SSLSetEnabledCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        c_size_t
+    ]
+    Security.SSLSetEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetNumberEnabledCiphers.argtype = [
+        SSLContextRef,
+        POINTER(c_size_t)
+    ]
+    Security.SSLGetNumberEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetEnabledCiphers.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite),
+        POINTER(c_size_t)
+    ]
+    Security.SSLGetEnabledCiphers.restype = OSStatus
+
+    Security.SSLGetNegotiatedCipher.argtypes = [
+        SSLContextRef,
+        POINTER(SSLCipherSuite)
+    ]
+    Security.SSLGetNegotiatedCipher.restype = OSStatus
+
+    Security.SSLGetNegotiatedProtocolVersion.argtypes = [
+        SSLContextRef,
+        POINTER(SSLProtocol)
+    ]
+    Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus
+
+    Security.SSLCopyPeerTrust.argtypes = [
+        SSLContextRef,
+        POINTER(SecTrustRef)
+    ]
+    Security.SSLCopyPeerTrust.restype = OSStatus
+
+    Security.SecTrustSetAnchorCertificates.argtypes = [
+        SecTrustRef,
+        CFArrayRef
+    ]
+    Security.SecTrustSetAnchorCertificates.restype = OSStatus
+
+    Security.SecTrustSetAnchorCertificatesOnly.argstypes = [
+        SecTrustRef,
+        Boolean
+    ]
+    Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus
+
+    Security.SecTrustEvaluate.argtypes = [
+        SecTrustRef,
+        POINTER(SecTrustResultType)
+    ]
+    Security.SecTrustEvaluate.restype = OSStatus
+
+    Security.SecTrustGetCertificateCount.argtypes = [
+        SecTrustRef
+    ]
+    Security.SecTrustGetCertificateCount.restype = CFIndex
+
+    Security.SecTrustGetCertificateAtIndex.argtypes = [
+        SecTrustRef,
+        CFIndex
+    ]
+    Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef
+
+    Security.SSLCreateContext.argtypes = [
+        CFAllocatorRef,
+        SSLProtocolSide,
+        SSLConnectionType
+    ]
+    Security.SSLCreateContext.restype = SSLContextRef
+
+    Security.SSLSetSessionOption.argtypes = [
+        SSLContextRef,
+        SSLSessionOption,
+        Boolean
+    ]
+    Security.SSLSetSessionOption.restype = OSStatus
+
+    Security.SSLSetProtocolVersionMin.argtypes = [
+        SSLContextRef,
+        SSLProtocol
+    ]
+    Security.SSLSetProtocolVersionMin.restype = OSStatus
+
+    Security.SSLSetProtocolVersionMax.argtypes = [
+        SSLContextRef,
+        SSLProtocol
+    ]
+    Security.SSLSetProtocolVersionMax.restype = OSStatus
+
+    Security.SecCopyErrorMessageString.argtypes = [
+        OSStatus,
+        c_void_p
+    ]
+    Security.SecCopyErrorMessageString.restype = CFStringRef
+
+    Security.SSLReadFunc = SSLReadFunc
+    Security.SSLWriteFunc = SSLWriteFunc
+    Security.SSLContextRef = SSLContextRef
+    Security.SSLProtocol = SSLProtocol
+    Security.SSLCipherSuite = SSLCipherSuite
+    Security.SecIdentityRef = SecIdentityRef
+    Security.SecKeychainRef = SecKeychainRef
+    Security.SecTrustRef = SecTrustRef
+    Security.SecTrustResultType = SecTrustResultType
+    Security.SecExternalFormat = SecExternalFormat
+    Security.OSStatus = OSStatus
+
+    Security.kSecImportExportPassphrase = CFStringRef.in_dll(
+        Security, 'kSecImportExportPassphrase'
+    )
+    Security.kSecImportItemIdentity = CFStringRef.in_dll(
+        Security, 'kSecImportItemIdentity'
+    )
+
+    # CoreFoundation time!
+    CoreFoundation.CFRetain.argtypes = [
+        CFTypeRef
+    ]
+    CoreFoundation.CFRetain.restype = CFTypeRef
+
+    CoreFoundation.CFRelease.argtypes = [
+        CFTypeRef
+    ]
+    CoreFoundation.CFRelease.restype = None
+
+    CoreFoundation.CFGetTypeID.argtypes = [
+        CFTypeRef
+    ]
+    CoreFoundation.CFGetTypeID.restype = CFTypeID
+
+    CoreFoundation.CFStringCreateWithCString.argtypes = [
+        CFAllocatorRef,
+        c_char_p,
+        CFStringEncoding
+    ]
+    CoreFoundation.CFStringCreateWithCString.restype = CFStringRef
+
+    CoreFoundation.CFStringGetCStringPtr.argtypes = [
+        CFStringRef,
+        CFStringEncoding
+    ]
+    CoreFoundation.CFStringGetCStringPtr.restype = c_char_p
+
+    CoreFoundation.CFStringGetCString.argtypes = [
+        CFStringRef,
+        c_char_p,
+        CFIndex,
+        CFStringEncoding
+    ]
+    CoreFoundation.CFStringGetCString.restype = c_bool
+
+    CoreFoundation.CFDataCreate.argtypes = [
+        CFAllocatorRef,
+        c_char_p,
+        CFIndex
+    ]
+    CoreFoundation.CFDataCreate.restype = CFDataRef
+
+    CoreFoundation.CFDataGetLength.argtypes = [
+        CFDataRef
+    ]
+    CoreFoundation.CFDataGetLength.restype = CFIndex
+
+    CoreFoundation.CFDataGetBytePtr.argtypes = [
+        CFDataRef
+    ]
+    CoreFoundation.CFDataGetBytePtr.restype = c_void_p
+
+    CoreFoundation.CFDictionaryCreate.argtypes = [
+        CFAllocatorRef,
+        POINTER(CFTypeRef),
+        POINTER(CFTypeRef),
+        CFIndex,
+        CFDictionaryKeyCallBacks,
+        CFDictionaryValueCallBacks
+    ]
+    CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef
+
+    CoreFoundation.CFDictionaryGetValue.argtypes = [
+        CFDictionaryRef,
+        CFTypeRef
+    ]
+    CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef
+
+    CoreFoundation.CFArrayCreate.argtypes = [
+        CFAllocatorRef,
+        POINTER(CFTypeRef),
+        CFIndex,
+        CFArrayCallBacks,
+    ]
+    CoreFoundation.CFArrayCreate.restype = CFArrayRef
+
+    CoreFoundation.CFArrayCreateMutable.argtypes = [
+        CFAllocatorRef,
+        CFIndex,
+        CFArrayCallBacks
+    ]
+    CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef
+
+    CoreFoundation.CFArrayAppendValue.argtypes = [
+        CFMutableArrayRef,
+        c_void_p
+    ]
+    CoreFoundation.CFArrayAppendValue.restype = None
+
+    CoreFoundation.CFArrayGetCount.argtypes = [
+        CFArrayRef
+    ]
+    CoreFoundation.CFArrayGetCount.restype = CFIndex
+
+    CoreFoundation.CFArrayGetValueAtIndex.argtypes = [
+        CFArrayRef,
+        CFIndex
+    ]
+    CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p
+
+    CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll(
+        CoreFoundation, 'kCFAllocatorDefault'
+    )
+    CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll(CoreFoundation, 'kCFTypeArrayCallBacks')
+    CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll(
+        CoreFoundation, 'kCFTypeDictionaryKeyCallBacks'
+    )
+    CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll(
+        CoreFoundation, 'kCFTypeDictionaryValueCallBacks'
+    )
+
+    CoreFoundation.CFTypeRef = CFTypeRef
+    CoreFoundation.CFArrayRef = CFArrayRef
+    CoreFoundation.CFStringRef = CFStringRef
+    CoreFoundation.CFDictionaryRef = CFDictionaryRef
+
+except (AttributeError):
+    raise ImportError('Error initializing ctypes')
+
+
+class CFConst(object):
+    """
+    A class object that acts as essentially a namespace for CoreFoundation
+    constants.
+    """
+    kCFStringEncodingUTF8 = CFStringEncoding(0x08000100)
+
+
+class SecurityConst(object):
+    """
+    A class object that acts as essentially a namespace for Security constants.
+    """
+    kSSLSessionOptionBreakOnServerAuth = 0
+
+    kSSLProtocol2 = 1
+    kSSLProtocol3 = 2
+    kTLSProtocol1 = 4
+    kTLSProtocol11 = 7
+    kTLSProtocol12 = 8
+    kTLSProtocol13 = 10
+    kTLSProtocolMaxSupported = 999
+
+    kSSLClientSide = 1
+    kSSLStreamType = 0
+
+    kSecFormatPEMSequence = 10
+
+    kSecTrustResultInvalid = 0
+    kSecTrustResultProceed = 1
+    # This gap is present on purpose: this was kSecTrustResultConfirm, which
+    # is deprecated.
+    kSecTrustResultDeny = 3
+    kSecTrustResultUnspecified = 4
+    kSecTrustResultRecoverableTrustFailure = 5
+    kSecTrustResultFatalTrustFailure = 6
+    kSecTrustResultOtherError = 7
+
+    errSSLProtocol = -9800
+    errSSLWouldBlock = -9803
+    errSSLClosedGraceful = -9805
+    errSSLClosedNoNotify = -9816
+    errSSLClosedAbort = -9806
+
+    errSSLXCertChainInvalid = -9807
+    errSSLCrypto = -9809
+    errSSLInternal = -9810
+    errSSLCertExpired = -9814
+    errSSLCertNotYetValid = -9815
+    errSSLUnknownRootCert = -9812
+    errSSLNoRootCert = -9813
+    errSSLHostNameMismatch = -9843
+    errSSLPeerHandshakeFail = -9824
+    errSSLPeerUserCancelled = -9839
+    errSSLWeakPeerEphemeralDHKey = -9850
+    errSSLServerAuthCompleted = -9841
+    errSSLRecordOverflow = -9847
+
+    errSecVerifyFailed = -67808
+    errSecNoTrustSettings = -25263
+    errSecItemNotFound = -25300
+    errSecInvalidTrustSettings = -25262
+
+    # Cipher suites. We only pick the ones our default cipher string allows.
+    # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values
+    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C
+    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030
+    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B
+    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F
+    TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9
+    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8
+    TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F
+    TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E
+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024
+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028
+    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A
+    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014
+    TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B
+    TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039
+    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023
+    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027
+    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009
+    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013
+    TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067
+    TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033
+    TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D
+    TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C
+    TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D
+    TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C
+    TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035
+    TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F
+    TLS_AES_128_GCM_SHA256 = 0x1301
+    TLS_AES_256_GCM_SHA384 = 0x1302
+    TLS_AES_128_CCM_8_SHA256 = 0x1305
+    TLS_AES_128_CCM_SHA256 = 0x1304
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py
new file mode 100644
index 0000000000000000000000000000000000000000..b13cd9e72c66abdc4a3bb47ab422495e9bba82fb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/_securetransport/low_level.py
@@ -0,0 +1,346 @@
+"""
+Low-level helpers for the SecureTransport bindings.
+
+These are Python functions that are not directly related to the high-level APIs
+but are necessary to get them to work. They include a whole bunch of low-level
+CoreFoundation messing about and memory management. The concerns in this module
+are almost entirely about trying to avoid memory leaks and providing
+appropriate and useful assistance to the higher-level code.
+"""
+import base64
+import ctypes
+import itertools
+import re
+import os
+import ssl
+import tempfile
+
+from .bindings import Security, CoreFoundation, CFConst
+
+
+# This regular expression is used to grab PEM data out of a PEM bundle.
+_PEM_CERTS_RE = re.compile(
+    b"-----BEGIN CERTIFICATE-----\n(.*?)\n-----END CERTIFICATE-----", re.DOTALL
+)
+
+
+def _cf_data_from_bytes(bytestring):
+    """
+    Given a bytestring, create a CFData object from it. This CFData object must
+    be CFReleased by the caller.
+    """
+    return CoreFoundation.CFDataCreate(
+        CoreFoundation.kCFAllocatorDefault, bytestring, len(bytestring)
+    )
+
+
+def _cf_dictionary_from_tuples(tuples):
+    """
+    Given a list of Python tuples, create an associated CFDictionary.
+    """
+    dictionary_size = len(tuples)
+
+    # We need to get the dictionary keys and values out in the same order.
+    keys = (t[0] for t in tuples)
+    values = (t[1] for t in tuples)
+    cf_keys = (CoreFoundation.CFTypeRef * dictionary_size)(*keys)
+    cf_values = (CoreFoundation.CFTypeRef * dictionary_size)(*values)
+
+    return CoreFoundation.CFDictionaryCreate(
+        CoreFoundation.kCFAllocatorDefault,
+        cf_keys,
+        cf_values,
+        dictionary_size,
+        CoreFoundation.kCFTypeDictionaryKeyCallBacks,
+        CoreFoundation.kCFTypeDictionaryValueCallBacks,
+    )
+
+
+def _cf_string_to_unicode(value):
+    """
+    Creates a Unicode string from a CFString object. Used entirely for error
+    reporting.
+
+    Yes, it annoys me quite a lot that this function is this complex.
+    """
+    value_as_void_p = ctypes.cast(value, ctypes.POINTER(ctypes.c_void_p))
+
+    string = CoreFoundation.CFStringGetCStringPtr(
+        value_as_void_p,
+        CFConst.kCFStringEncodingUTF8
+    )
+    if string is None:
+        buffer = ctypes.create_string_buffer(1024)
+        result = CoreFoundation.CFStringGetCString(
+            value_as_void_p,
+            buffer,
+            1024,
+            CFConst.kCFStringEncodingUTF8
+        )
+        if not result:
+            raise OSError('Error copying C string from CFStringRef')
+        string = buffer.value
+    if string is not None:
+        string = string.decode('utf-8')
+    return string
+
+
+def _assert_no_error(error, exception_class=None):
+    """
+    Checks the return code and throws an exception if there is an error to
+    report
+    """
+    if error == 0:
+        return
+
+    cf_error_string = Security.SecCopyErrorMessageString(error, None)
+    output = _cf_string_to_unicode(cf_error_string)
+    CoreFoundation.CFRelease(cf_error_string)
+
+    if output is None or output == u'':
+        output = u'OSStatus %s' % error
+
+    if exception_class is None:
+        exception_class = ssl.SSLError
+
+    raise exception_class(output)
+
+
+def _cert_array_from_pem(pem_bundle):
+    """
+    Given a bundle of certs in PEM format, turns them into a CFArray of certs
+    that can be used to validate a cert chain.
+    """
+    # Normalize the PEM bundle's line endings.
+    pem_bundle = pem_bundle.replace(b"\r\n", b"\n")
+
+    der_certs = [
+        base64.b64decode(match.group(1))
+        for match in _PEM_CERTS_RE.finditer(pem_bundle)
+    ]
+    if not der_certs:
+        raise ssl.SSLError("No root certificates specified")
+
+    cert_array = CoreFoundation.CFArrayCreateMutable(
+        CoreFoundation.kCFAllocatorDefault,
+        0,
+        ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks)
+    )
+    if not cert_array:
+        raise ssl.SSLError("Unable to allocate memory!")
+
+    try:
+        for der_bytes in der_certs:
+            certdata = _cf_data_from_bytes(der_bytes)
+            if not certdata:
+                raise ssl.SSLError("Unable to allocate memory!")
+            cert = Security.SecCertificateCreateWithData(
+                CoreFoundation.kCFAllocatorDefault, certdata
+            )
+            CoreFoundation.CFRelease(certdata)
+            if not cert:
+                raise ssl.SSLError("Unable to build cert object!")
+
+            CoreFoundation.CFArrayAppendValue(cert_array, cert)
+            CoreFoundation.CFRelease(cert)
+    except Exception:
+        # We need to free the array before the exception bubbles further.
+        # We only want to do that if an error occurs: otherwise, the caller
+        # should free.
+        CoreFoundation.CFRelease(cert_array)
+
+    return cert_array
+
+
+def _is_cert(item):
+    """
+    Returns True if a given CFTypeRef is a certificate.
+    """
+    expected = Security.SecCertificateGetTypeID()
+    return CoreFoundation.CFGetTypeID(item) == expected
+
+
+def _is_identity(item):
+    """
+    Returns True if a given CFTypeRef is an identity.
+    """
+    expected = Security.SecIdentityGetTypeID()
+    return CoreFoundation.CFGetTypeID(item) == expected
+
+
+def _temporary_keychain():
+    """
+    This function creates a temporary Mac keychain that we can use to work with
+    credentials. This keychain uses a one-time password and a temporary file to
+    store the data. We expect to have one keychain per socket. The returned
+    SecKeychainRef must be freed by the caller, including calling
+    SecKeychainDelete.
+
+    Returns a tuple of the SecKeychainRef and the path to the temporary
+    directory that contains it.
+    """
+    # Unfortunately, SecKeychainCreate requires a path to a keychain. This
+    # means we cannot use mkstemp to use a generic temporary file. Instead,
+    # we're going to create a temporary directory and a filename to use there.
+    # This filename will be 8 random bytes expanded into base64. We also need
+    # some random bytes to password-protect the keychain we're creating, so we
+    # ask for 40 random bytes.
+    random_bytes = os.urandom(40)
+    filename = base64.b16encode(random_bytes[:8]).decode('utf-8')
+    password = base64.b16encode(random_bytes[8:])  # Must be valid UTF-8
+    tempdirectory = tempfile.mkdtemp()
+
+    keychain_path = os.path.join(tempdirectory, filename).encode('utf-8')
+
+    # We now want to create the keychain itself.
+    keychain = Security.SecKeychainRef()
+    status = Security.SecKeychainCreate(
+        keychain_path,
+        len(password),
+        password,
+        False,
+        None,
+        ctypes.byref(keychain)
+    )
+    _assert_no_error(status)
+
+    # Having created the keychain, we want to pass it off to the caller.
+    return keychain, tempdirectory
+
+
+def _load_items_from_file(keychain, path):
+    """
+    Given a single file, loads all the trust objects from it into arrays and
+    the keychain.
+    Returns a tuple of lists: the first list is a list of identities, the
+    second a list of certs.
+    """
+    certificates = []
+    identities = []
+    result_array = None
+
+    with open(path, 'rb') as f:
+        raw_filedata = f.read()
+
+    try:
+        filedata = CoreFoundation.CFDataCreate(
+            CoreFoundation.kCFAllocatorDefault,
+            raw_filedata,
+            len(raw_filedata)
+        )
+        result_array = CoreFoundation.CFArrayRef()
+        result = Security.SecItemImport(
+            filedata,  # cert data
+            None,  # Filename, leaving it out for now
+            None,  # What the type of the file is, we don't care
+            None,  # what's in the file, we don't care
+            0,  # import flags
+            None,  # key params, can include passphrase in the future
+            keychain,  # The keychain to insert into
+            ctypes.byref(result_array)  # Results
+        )
+        _assert_no_error(result)
+
+        # A CFArray is not very useful to us as an intermediary
+        # representation, so we are going to extract the objects we want
+        # and then free the array. We don't need to keep hold of keys: the
+        # keychain already has them!
+        result_count = CoreFoundation.CFArrayGetCount(result_array)
+        for index in range(result_count):
+            item = CoreFoundation.CFArrayGetValueAtIndex(
+                result_array, index
+            )
+            item = ctypes.cast(item, CoreFoundation.CFTypeRef)
+
+            if _is_cert(item):
+                CoreFoundation.CFRetain(item)
+                certificates.append(item)
+            elif _is_identity(item):
+                CoreFoundation.CFRetain(item)
+                identities.append(item)
+    finally:
+        if result_array:
+            CoreFoundation.CFRelease(result_array)
+
+        CoreFoundation.CFRelease(filedata)
+
+    return (identities, certificates)
+
+
+def _load_client_cert_chain(keychain, *paths):
+    """
+    Load certificates and maybe keys from a number of files. Has the end goal
+    of returning a CFArray containing one SecIdentityRef, and then zero or more
+    SecCertificateRef objects, suitable for use as a client certificate trust
+    chain.
+    """
+    # Ok, the strategy.
+    #
+    # This relies on knowing that macOS will not give you a SecIdentityRef
+    # unless you have imported a key into a keychain. This is a somewhat
+    # artificial limitation of macOS (for example, it doesn't necessarily
+    # affect iOS), but there is nothing inside Security.framework that lets you
+    # get a SecIdentityRef without having a key in a keychain.
+    #
+    # So the policy here is we take all the files and iterate them in order.
+    # Each one will use SecItemImport to have one or more objects loaded from
+    # it. We will also point at a keychain that macOS can use to work with the
+    # private key.
+    #
+    # Once we have all the objects, we'll check what we actually have. If we
+    # already have a SecIdentityRef in hand, fab: we'll use that. Otherwise,
+    # we'll take the first certificate (which we assume to be our leaf) and
+    # ask the keychain to give us a SecIdentityRef with that cert's associated
+    # key.
+    #
+    # We'll then return a CFArray containing the trust chain: one
+    # SecIdentityRef and then zero-or-more SecCertificateRef objects. The
+    # responsibility for freeing this CFArray will be with the caller. This
+    # CFArray must remain alive for the entire connection, so in practice it
+    # will be stored with a single SSLSocket, along with the reference to the
+    # keychain.
+    certificates = []
+    identities = []
+
+    # Filter out bad paths.
+    paths = (path for path in paths if path)
+
+    try:
+        for file_path in paths:
+            new_identities, new_certs = _load_items_from_file(
+                keychain, file_path
+            )
+            identities.extend(new_identities)
+            certificates.extend(new_certs)
+
+        # Ok, we have everything. The question is: do we have an identity? If
+        # not, we want to grab one from the first cert we have.
+        if not identities:
+            new_identity = Security.SecIdentityRef()
+            status = Security.SecIdentityCreateWithCertificate(
+                keychain,
+                certificates[0],
+                ctypes.byref(new_identity)
+            )
+            _assert_no_error(status)
+            identities.append(new_identity)
+
+            # We now want to release the original certificate, as we no longer
+            # need it.
+            CoreFoundation.CFRelease(certificates.pop(0))
+
+        # We now need to build a new CFArray that holds the trust chain.
+        trust_chain = CoreFoundation.CFArrayCreateMutable(
+            CoreFoundation.kCFAllocatorDefault,
+            0,
+            ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks),
+        )
+        for item in itertools.chain(identities, certificates):
+            # ArrayAppendValue does a CFRetain on the item. That's fine,
+            # because the finally block will release our other refs to them.
+            CoreFoundation.CFArrayAppendValue(trust_chain, item)
+
+        return trust_chain
+    finally:
+        for obj in itertools.chain(identities, certificates):
+            CoreFoundation.CFRelease(obj)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/appengine.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/appengine.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b42952d7bf6b5b157bcc1ec3380193ecae6dade
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/appengine.py
@@ -0,0 +1,289 @@
+"""
+This module provides a pool manager that uses Google App Engine's
+`URLFetch Service <https://cloud.google.com/appengine/docs/python/urlfetch>`_.
+
+Example usage::
+
+    from pip._vendor.urllib3 import PoolManager
+    from pip._vendor.urllib3.contrib.appengine import AppEngineManager, is_appengine_sandbox
+
+    if is_appengine_sandbox():
+        # AppEngineManager uses AppEngine's URLFetch API behind the scenes
+        http = AppEngineManager()
+    else:
+        # PoolManager uses a socket-level API behind the scenes
+        http = PoolManager()
+
+    r = http.request('GET', 'https://google.com/')
+
+There are `limitations <https://cloud.google.com/appengine/docs/python/\
+urlfetch/#Python_Quotas_and_limits>`_ to the URLFetch service and it may not be
+the best choice for your application. There are three options for using
+urllib3 on Google App Engine:
+
+1. You can use :class:`AppEngineManager` with URLFetch. URLFetch is
+   cost-effective in many circumstances as long as your usage is within the
+   limitations.
+2. You can use a normal :class:`~urllib3.PoolManager` by enabling sockets.
+   Sockets also have `limitations and restrictions
+   <https://cloud.google.com/appengine/docs/python/sockets/\
+   #limitations-and-restrictions>`_ and have a lower free quota than URLFetch.
+   To use sockets, be sure to specify the following in your ``app.yaml``::
+
+        env_variables:
+            GAE_USE_SOCKETS_HTTPLIB : 'true'
+
+3. If you are using `App Engine Flexible
+<https://cloud.google.com/appengine/docs/flexible/>`_, you can use the standard
+:class:`PoolManager` without any configuration or special environment variables.
+"""
+
+from __future__ import absolute_import
+import io
+import logging
+import warnings
+from ..packages.six.moves.urllib.parse import urljoin
+
+from ..exceptions import (
+    HTTPError,
+    HTTPWarning,
+    MaxRetryError,
+    ProtocolError,
+    TimeoutError,
+    SSLError
+)
+
+from ..request import RequestMethods
+from ..response import HTTPResponse
+from ..util.timeout import Timeout
+from ..util.retry import Retry
+from . import _appengine_environ
+
+try:
+    from google.appengine.api import urlfetch
+except ImportError:
+    urlfetch = None
+
+
+log = logging.getLogger(__name__)
+
+
+class AppEnginePlatformWarning(HTTPWarning):
+    pass
+
+
+class AppEnginePlatformError(HTTPError):
+    pass
+
+
+class AppEngineManager(RequestMethods):
+    """
+    Connection manager for Google App Engine sandbox applications.
+
+    This manager uses the URLFetch service directly instead of using the
+    emulated httplib, and is subject to URLFetch limitations as described in
+    the App Engine documentation `here
+    <https://cloud.google.com/appengine/docs/python/urlfetch>`_.
+
+    Notably it will raise an :class:`AppEnginePlatformError` if:
+        * URLFetch is not available.
+        * If you attempt to use this on App Engine Flexible, as full socket
+          support is available.
+        * If a request size is more than 10 megabytes.
+        * If a response size is more than 32 megabtyes.
+        * If you use an unsupported request method such as OPTIONS.
+
+    Beyond those cases, it will raise normal urllib3 errors.
+    """
+
+    def __init__(self, headers=None, retries=None, validate_certificate=True,
+                 urlfetch_retries=True):
+        if not urlfetch:
+            raise AppEnginePlatformError(
+                "URLFetch is not available in this environment.")
+
+        if is_prod_appengine_mvms():
+            raise AppEnginePlatformError(
+                "Use normal urllib3.PoolManager instead of AppEngineManager"
+                "on Managed VMs, as using URLFetch is not necessary in "
+                "this environment.")
+
+        warnings.warn(
+            "urllib3 is using URLFetch on Google App Engine sandbox instead "
+            "of sockets. To use sockets directly instead of URLFetch see "
+            "https://urllib3.readthedocs.io/en/latest/reference/urllib3.contrib.html.",
+            AppEnginePlatformWarning)
+
+        RequestMethods.__init__(self, headers)
+        self.validate_certificate = validate_certificate
+        self.urlfetch_retries = urlfetch_retries
+
+        self.retries = retries or Retry.DEFAULT
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Return False to re-raise any potential exceptions
+        return False
+
+    def urlopen(self, method, url, body=None, headers=None,
+                retries=None, redirect=True, timeout=Timeout.DEFAULT_TIMEOUT,
+                **response_kw):
+
+        retries = self._get_retries(retries, redirect)
+
+        try:
+            follow_redirects = (
+                    redirect and
+                    retries.redirect != 0 and
+                    retries.total)
+            response = urlfetch.fetch(
+                url,
+                payload=body,
+                method=method,
+                headers=headers or {},
+                allow_truncated=False,
+                follow_redirects=self.urlfetch_retries and follow_redirects,
+                deadline=self._get_absolute_timeout(timeout),
+                validate_certificate=self.validate_certificate,
+            )
+        except urlfetch.DeadlineExceededError as e:
+            raise TimeoutError(self, e)
+
+        except urlfetch.InvalidURLError as e:
+            if 'too large' in str(e):
+                raise AppEnginePlatformError(
+                    "URLFetch request too large, URLFetch only "
+                    "supports requests up to 10mb in size.", e)
+            raise ProtocolError(e)
+
+        except urlfetch.DownloadError as e:
+            if 'Too many redirects' in str(e):
+                raise MaxRetryError(self, url, reason=e)
+            raise ProtocolError(e)
+
+        except urlfetch.ResponseTooLargeError as e:
+            raise AppEnginePlatformError(
+                "URLFetch response too large, URLFetch only supports"
+                "responses up to 32mb in size.", e)
+
+        except urlfetch.SSLCertificateError as e:
+            raise SSLError(e)
+
+        except urlfetch.InvalidMethodError as e:
+            raise AppEnginePlatformError(
+                "URLFetch does not support method: %s" % method, e)
+
+        http_response = self._urlfetch_response_to_http_response(
+            response, retries=retries, **response_kw)
+
+        # Handle redirect?
+        redirect_location = redirect and http_response.get_redirect_location()
+        if redirect_location:
+            # Check for redirect response
+            if (self.urlfetch_retries and retries.raise_on_redirect):
+                raise MaxRetryError(self, url, "too many redirects")
+            else:
+                if http_response.status == 303:
+                    method = 'GET'
+
+                try:
+                    retries = retries.increment(method, url, response=http_response, _pool=self)
+                except MaxRetryError:
+                    if retries.raise_on_redirect:
+                        raise MaxRetryError(self, url, "too many redirects")
+                    return http_response
+
+                retries.sleep_for_retry(http_response)
+                log.debug("Redirecting %s -> %s", url, redirect_location)
+                redirect_url = urljoin(url, redirect_location)
+                return self.urlopen(
+                    method, redirect_url, body, headers,
+                    retries=retries, redirect=redirect,
+                    timeout=timeout, **response_kw)
+
+        # Check if we should retry the HTTP response.
+        has_retry_after = bool(http_response.getheader('Retry-After'))
+        if retries.is_retry(method, http_response.status, has_retry_after):
+            retries = retries.increment(
+                method, url, response=http_response, _pool=self)
+            log.debug("Retry: %s", url)
+            retries.sleep(http_response)
+            return self.urlopen(
+                method, url,
+                body=body, headers=headers,
+                retries=retries, redirect=redirect,
+                timeout=timeout, **response_kw)
+
+        return http_response
+
+    def _urlfetch_response_to_http_response(self, urlfetch_resp, **response_kw):
+
+        if is_prod_appengine():
+            # Production GAE handles deflate encoding automatically, but does
+            # not remove the encoding header.
+            content_encoding = urlfetch_resp.headers.get('content-encoding')
+
+            if content_encoding == 'deflate':
+                del urlfetch_resp.headers['content-encoding']
+
+        transfer_encoding = urlfetch_resp.headers.get('transfer-encoding')
+        # We have a full response's content,
+        # so let's make sure we don't report ourselves as chunked data.
+        if transfer_encoding == 'chunked':
+            encodings = transfer_encoding.split(",")
+            encodings.remove('chunked')
+            urlfetch_resp.headers['transfer-encoding'] = ','.join(encodings)
+
+        original_response = HTTPResponse(
+            # In order for decoding to work, we must present the content as
+            # a file-like object.
+            body=io.BytesIO(urlfetch_resp.content),
+            msg=urlfetch_resp.header_msg,
+            headers=urlfetch_resp.headers,
+            status=urlfetch_resp.status_code,
+            **response_kw
+        )
+
+        return HTTPResponse(
+            body=io.BytesIO(urlfetch_resp.content),
+            headers=urlfetch_resp.headers,
+            status=urlfetch_resp.status_code,
+            original_response=original_response,
+            **response_kw
+        )
+
+    def _get_absolute_timeout(self, timeout):
+        if timeout is Timeout.DEFAULT_TIMEOUT:
+            return None  # Defer to URLFetch's default.
+        if isinstance(timeout, Timeout):
+            if timeout._read is not None or timeout._connect is not None:
+                warnings.warn(
+                    "URLFetch does not support granular timeout settings, "
+                    "reverting to total or default URLFetch timeout.",
+                    AppEnginePlatformWarning)
+            return timeout.total
+        return timeout
+
+    def _get_retries(self, retries, redirect):
+        if not isinstance(retries, Retry):
+            retries = Retry.from_int(
+                retries, redirect=redirect, default=self.retries)
+
+        if retries.connect or retries.read or retries.redirect:
+            warnings.warn(
+                "URLFetch only supports total retries and does not "
+                "recognize connect, read, or redirect retry parameters.",
+                AppEnginePlatformWarning)
+
+        return retries
+
+
+# Alias methods from _appengine_environ to maintain public API interface.
+
+is_appengine = _appengine_environ.is_appengine
+is_appengine_sandbox = _appengine_environ.is_appengine_sandbox
+is_local_appengine = _appengine_environ.is_local_appengine
+is_prod_appengine = _appengine_environ.is_prod_appengine
+is_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ea127c58338217fdcedb13feab027987d280e44
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/ntlmpool.py
@@ -0,0 +1,111 @@
+"""
+NTLM authenticating pool, contributed by erikcederstran
+
+Issue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10
+"""
+from __future__ import absolute_import
+
+from logging import getLogger
+from ntlm import ntlm
+
+from .. import HTTPSConnectionPool
+from ..packages.six.moves.http_client import HTTPSConnection
+
+
+log = getLogger(__name__)
+
+
+class NTLMConnectionPool(HTTPSConnectionPool):
+    """
+    Implements an NTLM authentication version of an urllib3 connection pool
+    """
+
+    scheme = 'https'
+
+    def __init__(self, user, pw, authurl, *args, **kwargs):
+        """
+        authurl is a random URL on the server that is protected by NTLM.
+        user is the Windows user, probably in the DOMAIN\\username format.
+        pw is the password for the user.
+        """
+        super(NTLMConnectionPool, self).__init__(*args, **kwargs)
+        self.authurl = authurl
+        self.rawuser = user
+        user_parts = user.split('\\', 1)
+        self.domain = user_parts[0].upper()
+        self.user = user_parts[1]
+        self.pw = pw
+
+    def _new_conn(self):
+        # Performs the NTLM handshake that secures the connection. The socket
+        # must be kept open while requests are performed.
+        self.num_connections += 1
+        log.debug('Starting NTLM HTTPS connection no. %d: https://%s%s',
+                  self.num_connections, self.host, self.authurl)
+
+        headers = {'Connection': 'Keep-Alive'}
+        req_header = 'Authorization'
+        resp_header = 'www-authenticate'
+
+        conn = HTTPSConnection(host=self.host, port=self.port)
+
+        # Send negotiation message
+        headers[req_header] = (
+            'NTLM %s' % ntlm.create_NTLM_NEGOTIATE_MESSAGE(self.rawuser))
+        log.debug('Request headers: %s', headers)
+        conn.request('GET', self.authurl, None, headers)
+        res = conn.getresponse()
+        reshdr = dict(res.getheaders())
+        log.debug('Response status: %s %s', res.status, res.reason)
+        log.debug('Response headers: %s', reshdr)
+        log.debug('Response data: %s [...]', res.read(100))
+
+        # Remove the reference to the socket, so that it can not be closed by
+        # the response object (we want to keep the socket open)
+        res.fp = None
+
+        # Server should respond with a challenge message
+        auth_header_values = reshdr[resp_header].split(', ')
+        auth_header_value = None
+        for s in auth_header_values:
+            if s[:5] == 'NTLM ':
+                auth_header_value = s[5:]
+        if auth_header_value is None:
+            raise Exception('Unexpected %s response header: %s' %
+                            (resp_header, reshdr[resp_header]))
+
+        # Send authentication message
+        ServerChallenge, NegotiateFlags = \
+            ntlm.parse_NTLM_CHALLENGE_MESSAGE(auth_header_value)
+        auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(ServerChallenge,
+                                                         self.user,
+                                                         self.domain,
+                                                         self.pw,
+                                                         NegotiateFlags)
+        headers[req_header] = 'NTLM %s' % auth_msg
+        log.debug('Request headers: %s', headers)
+        conn.request('GET', self.authurl, None, headers)
+        res = conn.getresponse()
+        log.debug('Response status: %s %s', res.status, res.reason)
+        log.debug('Response headers: %s', dict(res.getheaders()))
+        log.debug('Response data: %s [...]', res.read()[:100])
+        if res.status != 200:
+            if res.status == 401:
+                raise Exception('Server rejected request: wrong '
+                                'username or password')
+            raise Exception('Wrong server response: %s %s' %
+                            (res.status, res.reason))
+
+        res.fp = None
+        log.debug('Connection established')
+        return conn
+
+    def urlopen(self, method, url, body=None, headers=None, retries=3,
+                redirect=True, assert_same_host=True):
+        if headers is None:
+            headers = {}
+        headers['Connection'] = 'Keep-Alive'
+        return super(NTLMConnectionPool, self).urlopen(method, url, body,
+                                                       headers, retries,
+                                                       redirect,
+                                                       assert_same_host)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py
new file mode 100644
index 0000000000000000000000000000000000000000..abfc3191325a0f00ac3dcab8c5066a01843c96fd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/pyopenssl.py
@@ -0,0 +1,485 @@
+"""
+SSL with SNI_-support for Python 2. Follow these instructions if you would
+like to verify SSL certificates in Python 2. Note, the default libraries do
+*not* do certificate checking; you need to do additional work to validate
+certificates yourself.
+
+This needs the following packages installed:
+
+* pyOpenSSL (tested with 16.0.0)
+* cryptography (minimum 1.3.4, from pyopenssl)
+* idna (minimum 2.0, from cryptography)
+
+However, pyopenssl depends on cryptography, which depends on idna, so while we
+use all three directly here we end up having relatively few packages required.
+
+You can install them with the following command:
+
+    pip install pyopenssl cryptography idna
+
+To activate certificate checking, call
+:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code
+before you begin making HTTP requests. This can be done in a ``sitecustomize``
+module, or at any other time before your application begins using ``urllib3``,
+like this::
+
+    try:
+        import urllib3.contrib.pyopenssl
+        urllib3.contrib.pyopenssl.inject_into_urllib3()
+    except ImportError:
+        pass
+
+Now you can use :mod:`urllib3` as you normally would, and it will support SNI
+when the required modules are installed.
+
+Activating this module also has the positive side effect of disabling SSL/TLS
+compression in Python 2 (see `CRIME attack`_).
+
+If you want to configure the default list of supported cipher suites, you can
+set the ``urllib3.contrib.pyopenssl.DEFAULT_SSL_CIPHER_LIST`` variable.
+
+.. _sni: https://en.wikipedia.org/wiki/Server_Name_Indication
+.. _crime attack: https://en.wikipedia.org/wiki/CRIME_(security_exploit)
+"""
+from __future__ import absolute_import
+
+import OpenSSL.SSL
+from cryptography import x509
+from cryptography.hazmat.backends.openssl import backend as openssl_backend
+from cryptography.hazmat.backends.openssl.x509 import _Certificate
+try:
+    from cryptography.x509 import UnsupportedExtension
+except ImportError:
+    # UnsupportedExtension is gone in cryptography >= 2.1.0
+    class UnsupportedExtension(Exception):
+        pass
+
+from socket import timeout, error as SocketError
+from io import BytesIO
+
+try:  # Platform-specific: Python 2
+    from socket import _fileobject
+except ImportError:  # Platform-specific: Python 3
+    _fileobject = None
+    from ..packages.backports.makefile import backport_makefile
+
+import logging
+import ssl
+from ..packages import six
+import sys
+
+from .. import util
+
+
+__all__ = ['inject_into_urllib3', 'extract_from_urllib3']
+
+# SNI always works.
+HAS_SNI = True
+
+# Map from urllib3 to PyOpenSSL compatible parameter-values.
+_openssl_versions = {
+    util.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD,
+    ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD,
+}
+
+if hasattr(ssl, 'PROTOCOL_SSLv3') and hasattr(OpenSSL.SSL, 'SSLv3_METHOD'):
+    _openssl_versions[ssl.PROTOCOL_SSLv3] = OpenSSL.SSL.SSLv3_METHOD
+
+if hasattr(ssl, 'PROTOCOL_TLSv1_1') and hasattr(OpenSSL.SSL, 'TLSv1_1_METHOD'):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD
+
+if hasattr(ssl, 'PROTOCOL_TLSv1_2') and hasattr(OpenSSL.SSL, 'TLSv1_2_METHOD'):
+    _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD
+
+
+_stdlib_to_openssl_verify = {
+    ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE,
+    ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER,
+    ssl.CERT_REQUIRED:
+        OpenSSL.SSL.VERIFY_PEER + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
+}
+_openssl_to_stdlib_verify = dict(
+    (v, k) for k, v in _stdlib_to_openssl_verify.items()
+)
+
+# OpenSSL will only write 16K at a time
+SSL_WRITE_BLOCKSIZE = 16384
+
+orig_util_HAS_SNI = util.HAS_SNI
+orig_util_SSLContext = util.ssl_.SSLContext
+
+
+log = logging.getLogger(__name__)
+
+
+def inject_into_urllib3():
+    'Monkey-patch urllib3 with PyOpenSSL-backed SSL-support.'
+
+    _validate_dependencies_met()
+
+    util.SSLContext = PyOpenSSLContext
+    util.ssl_.SSLContext = PyOpenSSLContext
+    util.HAS_SNI = HAS_SNI
+    util.ssl_.HAS_SNI = HAS_SNI
+    util.IS_PYOPENSSL = True
+    util.ssl_.IS_PYOPENSSL = True
+
+
+def extract_from_urllib3():
+    'Undo monkey-patching by :func:`inject_into_urllib3`.'
+
+    util.SSLContext = orig_util_SSLContext
+    util.ssl_.SSLContext = orig_util_SSLContext
+    util.HAS_SNI = orig_util_HAS_SNI
+    util.ssl_.HAS_SNI = orig_util_HAS_SNI
+    util.IS_PYOPENSSL = False
+    util.ssl_.IS_PYOPENSSL = False
+
+
+def _validate_dependencies_met():
+    """
+    Verifies that PyOpenSSL's package-level dependencies have been met.
+    Throws `ImportError` if they are not met.
+    """
+    # Method added in `cryptography==1.1`; not available in older versions
+    from cryptography.x509.extensions import Extensions
+    if getattr(Extensions, "get_extension_for_class", None) is None:
+        raise ImportError("'cryptography' module missing required functionality.  "
+                          "Try upgrading to v1.3.4 or newer.")
+
+    # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509
+    # attribute is only present on those versions.
+    from OpenSSL.crypto import X509
+    x509 = X509()
+    if getattr(x509, "_x509", None) is None:
+        raise ImportError("'pyOpenSSL' module missing required functionality. "
+                          "Try upgrading to v0.14 or newer.")
+
+
+def _dnsname_to_stdlib(name):
+    """
+    Converts a dNSName SubjectAlternativeName field to the form used by the
+    standard library on the given Python version.
+
+    Cryptography produces a dNSName as a unicode string that was idna-decoded
+    from ASCII bytes. We need to idna-encode that string to get it back, and
+    then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib
+    uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8).
+
+    If the name cannot be idna-encoded then we return None signalling that
+    the name given should be skipped.
+    """
+    def idna_encode(name):
+        """
+        Borrowed wholesale from the Python Cryptography Project. It turns out
+        that we can't just safely call `idna.encode`: it can explode for
+        wildcard names. This avoids that problem.
+        """
+        from pip._vendor import idna
+
+        try:
+            for prefix in [u'*.', u'.']:
+                if name.startswith(prefix):
+                    name = name[len(prefix):]
+                    return prefix.encode('ascii') + idna.encode(name)
+            return idna.encode(name)
+        except idna.core.IDNAError:
+            return None
+
+    # Don't send IPv6 addresses through the IDNA encoder.
+    if ':' in name:
+        return name
+
+    name = idna_encode(name)
+    if name is None:
+        return None
+    elif sys.version_info >= (3, 0):
+        name = name.decode('utf-8')
+    return name
+
+
+def get_subj_alt_name(peer_cert):
+    """
+    Given an PyOpenSSL certificate, provides all the subject alternative names.
+    """
+    # Pass the cert to cryptography, which has much better APIs for this.
+    if hasattr(peer_cert, "to_cryptography"):
+        cert = peer_cert.to_cryptography()
+    else:
+        # This is technically using private APIs, but should work across all
+        # relevant versions before PyOpenSSL got a proper API for this.
+        cert = _Certificate(openssl_backend, peer_cert._x509)
+
+    # We want to find the SAN extension. Ask Cryptography to locate it (it's
+    # faster than looping in Python)
+    try:
+        ext = cert.extensions.get_extension_for_class(
+            x509.SubjectAlternativeName
+        ).value
+    except x509.ExtensionNotFound:
+        # No such extension, return the empty list.
+        return []
+    except (x509.DuplicateExtension, UnsupportedExtension,
+            x509.UnsupportedGeneralNameType, UnicodeError) as e:
+        # A problem has been found with the quality of the certificate. Assume
+        # no SAN field is present.
+        log.warning(
+            "A problem was encountered with the certificate that prevented "
+            "urllib3 from finding the SubjectAlternativeName field. This can "
+            "affect certificate validation. The error was %s",
+            e,
+        )
+        return []
+
+    # We want to return dNSName and iPAddress fields. We need to cast the IPs
+    # back to strings because the match_hostname function wants them as
+    # strings.
+    # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8
+    # decoded. This is pretty frustrating, but that's what the standard library
+    # does with certificates, and so we need to attempt to do the same.
+    # We also want to skip over names which cannot be idna encoded.
+    names = [
+        ('DNS', name) for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName))
+        if name is not None
+    ]
+    names.extend(
+        ('IP Address', str(name))
+        for name in ext.get_values_for_type(x509.IPAddress)
+    )
+
+    return names
+
+
+class WrappedSocket(object):
+    '''API-compatibility wrapper for Python OpenSSL's Connection-class.
+
+    Note: _makefile_refs, _drop() and _reuse() are needed for the garbage
+    collector of pypy.
+    '''
+
+    def __init__(self, connection, socket, suppress_ragged_eofs=True):
+        self.connection = connection
+        self.socket = socket
+        self.suppress_ragged_eofs = suppress_ragged_eofs
+        self._makefile_refs = 0
+        self._closed = False
+
+    def fileno(self):
+        return self.socket.fileno()
+
+    # Copy-pasted from Python 3.5 source code
+    def _decref_socketios(self):
+        if self._makefile_refs > 0:
+            self._makefile_refs -= 1
+        if self._closed:
+            self.close()
+
+    def recv(self, *args, **kwargs):
+        try:
+            data = self.connection.recv(*args, **kwargs)
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, 'Unexpected EOF'):
+                return b''
+            else:
+                raise SocketError(str(e))
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return b''
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout('The read operation timed out')
+            else:
+                return self.recv(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError("read error: %r" % e)
+        else:
+            return data
+
+    def recv_into(self, *args, **kwargs):
+        try:
+            return self.connection.recv_into(*args, **kwargs)
+        except OpenSSL.SSL.SysCallError as e:
+            if self.suppress_ragged_eofs and e.args == (-1, 'Unexpected EOF'):
+                return 0
+            else:
+                raise SocketError(str(e))
+        except OpenSSL.SSL.ZeroReturnError:
+            if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN:
+                return 0
+            else:
+                raise
+        except OpenSSL.SSL.WantReadError:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
+                raise timeout('The read operation timed out')
+            else:
+                return self.recv_into(*args, **kwargs)
+
+        # TLS 1.3 post-handshake authentication
+        except OpenSSL.SSL.Error as e:
+            raise ssl.SSLError("read error: %r" % e)
+
+    def settimeout(self, timeout):
+        return self.socket.settimeout(timeout)
+
+    def _send_until_done(self, data):
+        while True:
+            try:
+                return self.connection.send(data)
+            except OpenSSL.SSL.WantWriteError:
+                if not util.wait_for_write(self.socket, self.socket.gettimeout()):
+                    raise timeout()
+                continue
+            except OpenSSL.SSL.SysCallError as e:
+                raise SocketError(str(e))
+
+    def sendall(self, data):
+        total_sent = 0
+        while total_sent < len(data):
+            sent = self._send_until_done(data[total_sent:total_sent + SSL_WRITE_BLOCKSIZE])
+            total_sent += sent
+
+    def shutdown(self):
+        # FIXME rethrow compatible exceptions should we ever use this
+        self.connection.shutdown()
+
+    def close(self):
+        if self._makefile_refs < 1:
+            try:
+                self._closed = True
+                return self.connection.close()
+            except OpenSSL.SSL.Error:
+                return
+        else:
+            self._makefile_refs -= 1
+
+    def getpeercert(self, binary_form=False):
+        x509 = self.connection.get_peer_certificate()
+
+        if not x509:
+            return x509
+
+        if binary_form:
+            return OpenSSL.crypto.dump_certificate(
+                OpenSSL.crypto.FILETYPE_ASN1,
+                x509)
+
+        return {
+            'subject': (
+                (('commonName', x509.get_subject().CN),),
+            ),
+            'subjectAltName': get_subj_alt_name(x509)
+        }
+
+    def version(self):
+        return self.connection.get_protocol_version_name()
+
+    def _reuse(self):
+        self._makefile_refs += 1
+
+    def _drop(self):
+        if self._makefile_refs < 1:
+            self.close()
+        else:
+            self._makefile_refs -= 1
+
+
+if _fileobject:  # Platform-specific: Python 2
+    def makefile(self, mode, bufsize=-1):
+        self._makefile_refs += 1
+        return _fileobject(self, mode, bufsize, close=True)
+else:  # Platform-specific: Python 3
+    makefile = backport_makefile
+
+WrappedSocket.makefile = makefile
+
+
+class PyOpenSSLContext(object):
+    """
+    I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible
+    for translating the interface of the standard library ``SSLContext`` object
+    to calls into PyOpenSSL.
+    """
+    def __init__(self, protocol):
+        self.protocol = _openssl_versions[protocol]
+        self._ctx = OpenSSL.SSL.Context(self.protocol)
+        self._options = 0
+        self.check_hostname = False
+
+    @property
+    def options(self):
+        return self._options
+
+    @options.setter
+    def options(self, value):
+        self._options = value
+        self._ctx.set_options(value)
+
+    @property
+    def verify_mode(self):
+        return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()]
+
+    @verify_mode.setter
+    def verify_mode(self, value):
+        self._ctx.set_verify(
+            _stdlib_to_openssl_verify[value],
+            _verify_callback
+        )
+
+    def set_default_verify_paths(self):
+        self._ctx.set_default_verify_paths()
+
+    def set_ciphers(self, ciphers):
+        if isinstance(ciphers, six.text_type):
+            ciphers = ciphers.encode('utf-8')
+        self._ctx.set_cipher_list(ciphers)
+
+    def load_verify_locations(self, cafile=None, capath=None, cadata=None):
+        if cafile is not None:
+            cafile = cafile.encode('utf-8')
+        if capath is not None:
+            capath = capath.encode('utf-8')
+        self._ctx.load_verify_locations(cafile, capath)
+        if cadata is not None:
+            self._ctx.load_verify_locations(BytesIO(cadata))
+
+    def load_cert_chain(self, certfile, keyfile=None, password=None):
+        self._ctx.use_certificate_chain_file(certfile)
+        if password is not None:
+            if not isinstance(password, six.binary_type):
+                password = password.encode('utf-8')
+            self._ctx.set_passwd_cb(lambda *_: password)
+        self._ctx.use_privatekey_file(keyfile or certfile)
+
+    def wrap_socket(self, sock, server_side=False,
+                    do_handshake_on_connect=True, suppress_ragged_eofs=True,
+                    server_hostname=None):
+        cnx = OpenSSL.SSL.Connection(self._ctx, sock)
+
+        if isinstance(server_hostname, six.text_type):  # Platform-specific: Python 3
+            server_hostname = server_hostname.encode('utf-8')
+
+        if server_hostname is not None:
+            cnx.set_tlsext_host_name(server_hostname)
+
+        cnx.set_connect_state()
+
+        while True:
+            try:
+                cnx.do_handshake()
+            except OpenSSL.SSL.WantReadError:
+                if not util.wait_for_read(sock, sock.gettimeout()):
+                    raise timeout('select timed out')
+                continue
+            except OpenSSL.SSL.Error as e:
+                raise ssl.SSLError('bad handshake: %r' % e)
+            break
+
+        return WrappedSocket(cnx, sock)
+
+
+def _verify_callback(cnx, x509, err_no, err_depth, return_code):
+    return err_no == 0
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/securetransport.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/securetransport.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dc48484167ba5556c42e9dadc469d78320354dd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/securetransport.py
@@ -0,0 +1,853 @@
+"""
+SecureTranport support for urllib3 via ctypes.
+
+This makes platform-native TLS available to urllib3 users on macOS without the
+use of a compiler. This is an important feature because the Python Package
+Index is moving to become a TLSv1.2-or-higher server, and the default OpenSSL
+that ships with macOS is not capable of doing TLSv1.2. The only way to resolve
+this is to give macOS users an alternative solution to the problem, and that
+solution is to use SecureTransport.
+
+We use ctypes here because this solution must not require a compiler. That's
+because pip is not allowed to require a compiler either.
+
+This is not intended to be a seriously long-term solution to this problem.
+The hope is that PEP 543 will eventually solve this issue for us, at which
+point we can retire this contrib module. But in the short term, we need to
+solve the impending tire fire that is Python on Mac without this kind of
+contrib module. So...here we are.
+
+To use this module, simply import and inject it::
+
+    import urllib3.contrib.securetransport
+    urllib3.contrib.securetransport.inject_into_urllib3()
+
+Happy TLSing!
+
+This code is a bastardised version of the code found in Will Bond's oscrypto
+library. An enormous debt is owed to him for blazing this trail for us. For
+that reason, this code should be considered to be covered both by urllib3's
+license and by oscrypto's:
+
+    Copyright (c) 2015-2016 Will Bond <will@wbond.net>
+
+    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.
+"""
+from __future__ import absolute_import
+
+import contextlib
+import ctypes
+import errno
+import os.path
+import shutil
+import socket
+import ssl
+import threading
+import weakref
+
+from .. import util
+from ._securetransport.bindings import (
+    Security, SecurityConst, CoreFoundation
+)
+from ._securetransport.low_level import (
+    _assert_no_error, _cert_array_from_pem, _temporary_keychain,
+    _load_client_cert_chain
+)
+
+try:  # Platform-specific: Python 2
+    from socket import _fileobject
+except ImportError:  # Platform-specific: Python 3
+    _fileobject = None
+    from ..packages.backports.makefile import backport_makefile
+
+__all__ = ['inject_into_urllib3', 'extract_from_urllib3']
+
+# SNI always works
+HAS_SNI = True
+
+orig_util_HAS_SNI = util.HAS_SNI
+orig_util_SSLContext = util.ssl_.SSLContext
+
+# This dictionary is used by the read callback to obtain a handle to the
+# calling wrapped socket. This is a pretty silly approach, but for now it'll
+# do. I feel like I should be able to smuggle a handle to the wrapped socket
+# directly in the SSLConnectionRef, but for now this approach will work I
+# guess.
+#
+# We need to lock around this structure for inserts, but we don't do it for
+# reads/writes in the callbacks. The reasoning here goes as follows:
+#
+#    1. It is not possible to call into the callbacks before the dictionary is
+#       populated, so once in the callback the id must be in the dictionary.
+#    2. The callbacks don't mutate the dictionary, they only read from it, and
+#       so cannot conflict with any of the insertions.
+#
+# This is good: if we had to lock in the callbacks we'd drastically slow down
+# the performance of this code.
+_connection_refs = weakref.WeakValueDictionary()
+_connection_ref_lock = threading.Lock()
+
+# Limit writes to 16kB. This is OpenSSL's limit, but we'll cargo-cult it over
+# for no better reason than we need *a* limit, and this one is right there.
+SSL_WRITE_BLOCKSIZE = 16384
+
+# This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to
+# individual cipher suites. We need to do this because this is how
+# SecureTransport wants them.
+CIPHER_SUITES = [
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
+    SecurityConst.TLS_AES_256_GCM_SHA384,
+    SecurityConst.TLS_AES_128_GCM_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_GCM_SHA384,
+    SecurityConst.TLS_RSA_WITH_AES_128_GCM_SHA256,
+    SecurityConst.TLS_AES_128_CCM_8_SHA256,
+    SecurityConst.TLS_AES_128_CCM_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA256,
+    SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA,
+    SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA,
+]
+
+# Basically this is simple: for PROTOCOL_SSLv23 we turn it into a low of
+# TLSv1 and a high of TLSv1.3. For everything else, we pin to that version.
+# TLSv1 to 1.2 are supported on macOS 10.8+ and TLSv1.3 is macOS 10.13+
+_protocol_to_min_max = {
+    util.PROTOCOL_TLS: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocolMaxSupported),
+}
+
+if hasattr(ssl, "PROTOCOL_SSLv2"):
+    _protocol_to_min_max[ssl.PROTOCOL_SSLv2] = (
+        SecurityConst.kSSLProtocol2, SecurityConst.kSSLProtocol2
+    )
+if hasattr(ssl, "PROTOCOL_SSLv3"):
+    _protocol_to_min_max[ssl.PROTOCOL_SSLv3] = (
+        SecurityConst.kSSLProtocol3, SecurityConst.kSSLProtocol3
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1] = (
+        SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol1
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1_1"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1_1] = (
+        SecurityConst.kTLSProtocol11, SecurityConst.kTLSProtocol11
+    )
+if hasattr(ssl, "PROTOCOL_TLSv1_2"):
+    _protocol_to_min_max[ssl.PROTOCOL_TLSv1_2] = (
+        SecurityConst.kTLSProtocol12, SecurityConst.kTLSProtocol12
+    )
+
+
+def inject_into_urllib3():
+    """
+    Monkey-patch urllib3 with SecureTransport-backed SSL-support.
+    """
+    util.SSLContext = SecureTransportContext
+    util.ssl_.SSLContext = SecureTransportContext
+    util.HAS_SNI = HAS_SNI
+    util.ssl_.HAS_SNI = HAS_SNI
+    util.IS_SECURETRANSPORT = True
+    util.ssl_.IS_SECURETRANSPORT = True
+
+
+def extract_from_urllib3():
+    """
+    Undo monkey-patching by :func:`inject_into_urllib3`.
+    """
+    util.SSLContext = orig_util_SSLContext
+    util.ssl_.SSLContext = orig_util_SSLContext
+    util.HAS_SNI = orig_util_HAS_SNI
+    util.ssl_.HAS_SNI = orig_util_HAS_SNI
+    util.IS_SECURETRANSPORT = False
+    util.ssl_.IS_SECURETRANSPORT = False
+
+
+def _read_callback(connection_id, data_buffer, data_length_pointer):
+    """
+    SecureTransport read callback. This is called by ST to request that data
+    be returned from the socket.
+    """
+    wrapped_socket = None
+    try:
+        wrapped_socket = _connection_refs.get(connection_id)
+        if wrapped_socket is None:
+            return SecurityConst.errSSLInternal
+        base_socket = wrapped_socket.socket
+
+        requested_length = data_length_pointer[0]
+
+        timeout = wrapped_socket.gettimeout()
+        error = None
+        read_count = 0
+
+        try:
+            while read_count < requested_length:
+                if timeout is None or timeout >= 0:
+                    if not util.wait_for_read(base_socket, timeout):
+                        raise socket.error(errno.EAGAIN, 'timed out')
+
+                remaining = requested_length - read_count
+                buffer = (ctypes.c_char * remaining).from_address(
+                    data_buffer + read_count
+                )
+                chunk_size = base_socket.recv_into(buffer, remaining)
+                read_count += chunk_size
+                if not chunk_size:
+                    if not read_count:
+                        return SecurityConst.errSSLClosedGraceful
+                    break
+        except (socket.error) as e:
+            error = e.errno
+
+            if error is not None and error != errno.EAGAIN:
+                data_length_pointer[0] = read_count
+                if error == errno.ECONNRESET or error == errno.EPIPE:
+                    return SecurityConst.errSSLClosedAbort
+                raise
+
+        data_length_pointer[0] = read_count
+
+        if read_count != requested_length:
+            return SecurityConst.errSSLWouldBlock
+
+        return 0
+    except Exception as e:
+        if wrapped_socket is not None:
+            wrapped_socket._exception = e
+        return SecurityConst.errSSLInternal
+
+
+def _write_callback(connection_id, data_buffer, data_length_pointer):
+    """
+    SecureTransport write callback. This is called by ST to request that data
+    actually be sent on the network.
+    """
+    wrapped_socket = None
+    try:
+        wrapped_socket = _connection_refs.get(connection_id)
+        if wrapped_socket is None:
+            return SecurityConst.errSSLInternal
+        base_socket = wrapped_socket.socket
+
+        bytes_to_write = data_length_pointer[0]
+        data = ctypes.string_at(data_buffer, bytes_to_write)
+
+        timeout = wrapped_socket.gettimeout()
+        error = None
+        sent = 0
+
+        try:
+            while sent < bytes_to_write:
+                if timeout is None or timeout >= 0:
+                    if not util.wait_for_write(base_socket, timeout):
+                        raise socket.error(errno.EAGAIN, 'timed out')
+                chunk_sent = base_socket.send(data)
+                sent += chunk_sent
+
+                # This has some needless copying here, but I'm not sure there's
+                # much value in optimising this data path.
+                data = data[chunk_sent:]
+        except (socket.error) as e:
+            error = e.errno
+
+            if error is not None and error != errno.EAGAIN:
+                data_length_pointer[0] = sent
+                if error == errno.ECONNRESET or error == errno.EPIPE:
+                    return SecurityConst.errSSLClosedAbort
+                raise
+
+        data_length_pointer[0] = sent
+
+        if sent != bytes_to_write:
+            return SecurityConst.errSSLWouldBlock
+
+        return 0
+    except Exception as e:
+        if wrapped_socket is not None:
+            wrapped_socket._exception = e
+        return SecurityConst.errSSLInternal
+
+
+# We need to keep these two objects references alive: if they get GC'd while
+# in use then SecureTransport could attempt to call a function that is in freed
+# memory. That would be...uh...bad. Yeah, that's the word. Bad.
+_read_callback_pointer = Security.SSLReadFunc(_read_callback)
+_write_callback_pointer = Security.SSLWriteFunc(_write_callback)
+
+
+class WrappedSocket(object):
+    """
+    API-compatibility wrapper for Python's OpenSSL wrapped socket object.
+
+    Note: _makefile_refs, _drop(), and _reuse() are needed for the garbage
+    collector of PyPy.
+    """
+    def __init__(self, socket):
+        self.socket = socket
+        self.context = None
+        self._makefile_refs = 0
+        self._closed = False
+        self._exception = None
+        self._keychain = None
+        self._keychain_dir = None
+        self._client_cert_chain = None
+
+        # We save off the previously-configured timeout and then set it to
+        # zero. This is done because we use select and friends to handle the
+        # timeouts, but if we leave the timeout set on the lower socket then
+        # Python will "kindly" call select on that socket again for us. Avoid
+        # that by forcing the timeout to zero.
+        self._timeout = self.socket.gettimeout()
+        self.socket.settimeout(0)
+
+    @contextlib.contextmanager
+    def _raise_on_error(self):
+        """
+        A context manager that can be used to wrap calls that do I/O from
+        SecureTransport. If any of the I/O callbacks hit an exception, this
+        context manager will correctly propagate the exception after the fact.
+        This avoids silently swallowing those exceptions.
+
+        It also correctly forces the socket closed.
+        """
+        self._exception = None
+
+        # We explicitly don't catch around this yield because in the unlikely
+        # event that an exception was hit in the block we don't want to swallow
+        # it.
+        yield
+        if self._exception is not None:
+            exception, self._exception = self._exception, None
+            self.close()
+            raise exception
+
+    def _set_ciphers(self):
+        """
+        Sets up the allowed ciphers. By default this matches the set in
+        util.ssl_.DEFAULT_CIPHERS, at least as supported by macOS. This is done
+        custom and doesn't allow changing at this time, mostly because parsing
+        OpenSSL cipher strings is going to be a freaking nightmare.
+        """
+        ciphers = (Security.SSLCipherSuite * len(CIPHER_SUITES))(*CIPHER_SUITES)
+        result = Security.SSLSetEnabledCiphers(
+            self.context, ciphers, len(CIPHER_SUITES)
+        )
+        _assert_no_error(result)
+
+    def _custom_validate(self, verify, trust_bundle):
+        """
+        Called when we have set custom validation. We do this in two cases:
+        first, when cert validation is entirely disabled; and second, when
+        using a custom trust DB.
+        """
+        # If we disabled cert validation, just say: cool.
+        if not verify:
+            return
+
+        # We want data in memory, so load it up.
+        if os.path.isfile(trust_bundle):
+            with open(trust_bundle, 'rb') as f:
+                trust_bundle = f.read()
+
+        cert_array = None
+        trust = Security.SecTrustRef()
+
+        try:
+            # Get a CFArray that contains the certs we want.
+            cert_array = _cert_array_from_pem(trust_bundle)
+
+            # Ok, now the hard part. We want to get the SecTrustRef that ST has
+            # created for this connection, shove our CAs into it, tell ST to
+            # ignore everything else it knows, and then ask if it can build a
+            # chain. This is a buuuunch of code.
+            result = Security.SSLCopyPeerTrust(
+                self.context, ctypes.byref(trust)
+            )
+            _assert_no_error(result)
+            if not trust:
+                raise ssl.SSLError("Failed to copy trust reference")
+
+            result = Security.SecTrustSetAnchorCertificates(trust, cert_array)
+            _assert_no_error(result)
+
+            result = Security.SecTrustSetAnchorCertificatesOnly(trust, True)
+            _assert_no_error(result)
+
+            trust_result = Security.SecTrustResultType()
+            result = Security.SecTrustEvaluate(
+                trust, ctypes.byref(trust_result)
+            )
+            _assert_no_error(result)
+        finally:
+            if trust:
+                CoreFoundation.CFRelease(trust)
+
+            if cert_array is not None:
+                CoreFoundation.CFRelease(cert_array)
+
+        # Ok, now we can look at what the result was.
+        successes = (
+            SecurityConst.kSecTrustResultUnspecified,
+            SecurityConst.kSecTrustResultProceed
+        )
+        if trust_result.value not in successes:
+            raise ssl.SSLError(
+                "certificate verify failed, error code: %d" %
+                trust_result.value
+            )
+
+    def handshake(self,
+                  server_hostname,
+                  verify,
+                  trust_bundle,
+                  min_version,
+                  max_version,
+                  client_cert,
+                  client_key,
+                  client_key_passphrase):
+        """
+        Actually performs the TLS handshake. This is run automatically by
+        wrapped socket, and shouldn't be needed in user code.
+        """
+        # First, we do the initial bits of connection setup. We need to create
+        # a context, set its I/O funcs, and set the connection reference.
+        self.context = Security.SSLCreateContext(
+            None, SecurityConst.kSSLClientSide, SecurityConst.kSSLStreamType
+        )
+        result = Security.SSLSetIOFuncs(
+            self.context, _read_callback_pointer, _write_callback_pointer
+        )
+        _assert_no_error(result)
+
+        # Here we need to compute the handle to use. We do this by taking the
+        # id of self modulo 2**31 - 1. If this is already in the dictionary, we
+        # just keep incrementing by one until we find a free space.
+        with _connection_ref_lock:
+            handle = id(self) % 2147483647
+            while handle in _connection_refs:
+                handle = (handle + 1) % 2147483647
+            _connection_refs[handle] = self
+
+        result = Security.SSLSetConnection(self.context, handle)
+        _assert_no_error(result)
+
+        # If we have a server hostname, we should set that too.
+        if server_hostname:
+            if not isinstance(server_hostname, bytes):
+                server_hostname = server_hostname.encode('utf-8')
+
+            result = Security.SSLSetPeerDomainName(
+                self.context, server_hostname, len(server_hostname)
+            )
+            _assert_no_error(result)
+
+        # Setup the ciphers.
+        self._set_ciphers()
+
+        # Set the minimum and maximum TLS versions.
+        result = Security.SSLSetProtocolVersionMin(self.context, min_version)
+        _assert_no_error(result)
+
+        # TLS 1.3 isn't necessarily enabled by the OS
+        # so we have to detect when we error out and try
+        # setting TLS 1.3 if it's allowed. kTLSProtocolMaxSupported
+        # was added in macOS 10.13 along with kTLSProtocol13.
+        result = Security.SSLSetProtocolVersionMax(self.context, max_version)
+        if result != 0 and max_version == SecurityConst.kTLSProtocolMaxSupported:
+            result = Security.SSLSetProtocolVersionMax(self.context, SecurityConst.kTLSProtocol12)
+        _assert_no_error(result)
+
+        # If there's a trust DB, we need to use it. We do that by telling
+        # SecureTransport to break on server auth. We also do that if we don't
+        # want to validate the certs at all: we just won't actually do any
+        # authing in that case.
+        if not verify or trust_bundle is not None:
+            result = Security.SSLSetSessionOption(
+                self.context,
+                SecurityConst.kSSLSessionOptionBreakOnServerAuth,
+                True
+            )
+            _assert_no_error(result)
+
+        # If there's a client cert, we need to use it.
+        if client_cert:
+            self._keychain, self._keychain_dir = _temporary_keychain()
+            self._client_cert_chain = _load_client_cert_chain(
+                self._keychain, client_cert, client_key
+            )
+            result = Security.SSLSetCertificate(
+                self.context, self._client_cert_chain
+            )
+            _assert_no_error(result)
+
+        while True:
+            with self._raise_on_error():
+                result = Security.SSLHandshake(self.context)
+
+                if result == SecurityConst.errSSLWouldBlock:
+                    raise socket.timeout("handshake timed out")
+                elif result == SecurityConst.errSSLServerAuthCompleted:
+                    self._custom_validate(verify, trust_bundle)
+                    continue
+                else:
+                    _assert_no_error(result)
+                    break
+
+    def fileno(self):
+        return self.socket.fileno()
+
+    # Copy-pasted from Python 3.5 source code
+    def _decref_socketios(self):
+        if self._makefile_refs > 0:
+            self._makefile_refs -= 1
+        if self._closed:
+            self.close()
+
+    def recv(self, bufsiz):
+        buffer = ctypes.create_string_buffer(bufsiz)
+        bytes_read = self.recv_into(buffer, bufsiz)
+        data = buffer[:bytes_read]
+        return data
+
+    def recv_into(self, buffer, nbytes=None):
+        # Read short on EOF.
+        if self._closed:
+            return 0
+
+        if nbytes is None:
+            nbytes = len(buffer)
+
+        buffer = (ctypes.c_char * nbytes).from_buffer(buffer)
+        processed_bytes = ctypes.c_size_t(0)
+
+        with self._raise_on_error():
+            result = Security.SSLRead(
+                self.context, buffer, nbytes, ctypes.byref(processed_bytes)
+            )
+
+        # There are some result codes that we want to treat as "not always
+        # errors". Specifically, those are errSSLWouldBlock,
+        # errSSLClosedGraceful, and errSSLClosedNoNotify.
+        if (result == SecurityConst.errSSLWouldBlock):
+            # If we didn't process any bytes, then this was just a time out.
+            # However, we can get errSSLWouldBlock in situations when we *did*
+            # read some data, and in those cases we should just read "short"
+            # and return.
+            if processed_bytes.value == 0:
+                # Timed out, no data read.
+                raise socket.timeout("recv timed out")
+        elif result in (SecurityConst.errSSLClosedGraceful, SecurityConst.errSSLClosedNoNotify):
+            # The remote peer has closed this connection. We should do so as
+            # well. Note that we don't actually return here because in
+            # principle this could actually be fired along with return data.
+            # It's unlikely though.
+            self.close()
+        else:
+            _assert_no_error(result)
+
+        # Ok, we read and probably succeeded. We should return whatever data
+        # was actually read.
+        return processed_bytes.value
+
+    def settimeout(self, timeout):
+        self._timeout = timeout
+
+    def gettimeout(self):
+        return self._timeout
+
+    def send(self, data):
+        processed_bytes = ctypes.c_size_t(0)
+
+        with self._raise_on_error():
+            result = Security.SSLWrite(
+                self.context, data, len(data), ctypes.byref(processed_bytes)
+            )
+
+        if result == SecurityConst.errSSLWouldBlock and processed_bytes.value == 0:
+            # Timed out
+            raise socket.timeout("send timed out")
+        else:
+            _assert_no_error(result)
+
+        # We sent, and probably succeeded. Tell them how much we sent.
+        return processed_bytes.value
+
+    def sendall(self, data):
+        total_sent = 0
+        while total_sent < len(data):
+            sent = self.send(data[total_sent:total_sent + SSL_WRITE_BLOCKSIZE])
+            total_sent += sent
+
+    def shutdown(self):
+        with self._raise_on_error():
+            Security.SSLClose(self.context)
+
+    def close(self):
+        # TODO: should I do clean shutdown here? Do I have to?
+        if self._makefile_refs < 1:
+            self._closed = True
+            if self.context:
+                CoreFoundation.CFRelease(self.context)
+                self.context = None
+            if self._client_cert_chain:
+                CoreFoundation.CFRelease(self._client_cert_chain)
+                self._client_cert_chain = None
+            if self._keychain:
+                Security.SecKeychainDelete(self._keychain)
+                CoreFoundation.CFRelease(self._keychain)
+                shutil.rmtree(self._keychain_dir)
+                self._keychain = self._keychain_dir = None
+            return self.socket.close()
+        else:
+            self._makefile_refs -= 1
+
+    def getpeercert(self, binary_form=False):
+        # Urgh, annoying.
+        #
+        # Here's how we do this:
+        #
+        # 1. Call SSLCopyPeerTrust to get hold of the trust object for this
+        #    connection.
+        # 2. Call SecTrustGetCertificateAtIndex for index 0 to get the leaf.
+        # 3. To get the CN, call SecCertificateCopyCommonName and process that
+        #    string so that it's of the appropriate type.
+        # 4. To get the SAN, we need to do something a bit more complex:
+        #    a. Call SecCertificateCopyValues to get the data, requesting
+        #       kSecOIDSubjectAltName.
+        #    b. Mess about with this dictionary to try to get the SANs out.
+        #
+        # This is gross. Really gross. It's going to be a few hundred LoC extra
+        # just to repeat something that SecureTransport can *already do*. So my
+        # operating assumption at this time is that what we want to do is
+        # instead to just flag to urllib3 that it shouldn't do its own hostname
+        # validation when using SecureTransport.
+        if not binary_form:
+            raise ValueError(
+                "SecureTransport only supports dumping binary certs"
+            )
+        trust = Security.SecTrustRef()
+        certdata = None
+        der_bytes = None
+
+        try:
+            # Grab the trust store.
+            result = Security.SSLCopyPeerTrust(
+                self.context, ctypes.byref(trust)
+            )
+            _assert_no_error(result)
+            if not trust:
+                # Probably we haven't done the handshake yet. No biggie.
+                return None
+
+            cert_count = Security.SecTrustGetCertificateCount(trust)
+            if not cert_count:
+                # Also a case that might happen if we haven't handshaked.
+                # Handshook? Handshaken?
+                return None
+
+            leaf = Security.SecTrustGetCertificateAtIndex(trust, 0)
+            assert leaf
+
+            # Ok, now we want the DER bytes.
+            certdata = Security.SecCertificateCopyData(leaf)
+            assert certdata
+
+            data_length = CoreFoundation.CFDataGetLength(certdata)
+            data_buffer = CoreFoundation.CFDataGetBytePtr(certdata)
+            der_bytes = ctypes.string_at(data_buffer, data_length)
+        finally:
+            if certdata:
+                CoreFoundation.CFRelease(certdata)
+            if trust:
+                CoreFoundation.CFRelease(trust)
+
+        return der_bytes
+
+    def version(self):
+        protocol = Security.SSLProtocol()
+        result = Security.SSLGetNegotiatedProtocolVersion(self.context, ctypes.byref(protocol))
+        _assert_no_error(result)
+        if protocol.value == SecurityConst.kTLSProtocol13:
+            return 'TLSv1.3'
+        elif protocol.value == SecurityConst.kTLSProtocol12:
+            return 'TLSv1.2'
+        elif protocol.value == SecurityConst.kTLSProtocol11:
+            return 'TLSv1.1'
+        elif protocol.value == SecurityConst.kTLSProtocol1:
+            return 'TLSv1'
+        elif protocol.value == SecurityConst.kSSLProtocol3:
+            return 'SSLv3'
+        elif protocol.value == SecurityConst.kSSLProtocol2:
+            return 'SSLv2'
+        else:
+            raise ssl.SSLError('Unknown TLS version: %r' % protocol)
+
+    def _reuse(self):
+        self._makefile_refs += 1
+
+    def _drop(self):
+        if self._makefile_refs < 1:
+            self.close()
+        else:
+            self._makefile_refs -= 1
+
+
+if _fileobject:  # Platform-specific: Python 2
+    def makefile(self, mode, bufsize=-1):
+        self._makefile_refs += 1
+        return _fileobject(self, mode, bufsize, close=True)
+else:  # Platform-specific: Python 3
+    def makefile(self, mode="r", buffering=None, *args, **kwargs):
+        # We disable buffering with SecureTransport because it conflicts with
+        # the buffering that ST does internally (see issue #1153 for more).
+        buffering = 0
+        return backport_makefile(self, mode, buffering, *args, **kwargs)
+
+WrappedSocket.makefile = makefile
+
+
+class SecureTransportContext(object):
+    """
+    I am a wrapper class for the SecureTransport library, to translate the
+    interface of the standard library ``SSLContext`` object to calls into
+    SecureTransport.
+    """
+    def __init__(self, protocol):
+        self._min_version, self._max_version = _protocol_to_min_max[protocol]
+        self._options = 0
+        self._verify = False
+        self._trust_bundle = None
+        self._client_cert = None
+        self._client_key = None
+        self._client_key_passphrase = None
+
+    @property
+    def check_hostname(self):
+        """
+        SecureTransport cannot have its hostname checking disabled. For more,
+        see the comment on getpeercert() in this file.
+        """
+        return True
+
+    @check_hostname.setter
+    def check_hostname(self, value):
+        """
+        SecureTransport cannot have its hostname checking disabled. For more,
+        see the comment on getpeercert() in this file.
+        """
+        pass
+
+    @property
+    def options(self):
+        # TODO: Well, crap.
+        #
+        # So this is the bit of the code that is the most likely to cause us
+        # trouble. Essentially we need to enumerate all of the SSL options that
+        # users might want to use and try to see if we can sensibly translate
+        # them, or whether we should just ignore them.
+        return self._options
+
+    @options.setter
+    def options(self, value):
+        # TODO: Update in line with above.
+        self._options = value
+
+    @property
+    def verify_mode(self):
+        return ssl.CERT_REQUIRED if self._verify else ssl.CERT_NONE
+
+    @verify_mode.setter
+    def verify_mode(self, value):
+        self._verify = True if value == ssl.CERT_REQUIRED else False
+
+    def set_default_verify_paths(self):
+        # So, this has to do something a bit weird. Specifically, what it does
+        # is nothing.
+        #
+        # This means that, if we had previously had load_verify_locations
+        # called, this does not undo that. We need to do that because it turns
+        # out that the rest of the urllib3 code will attempt to load the
+        # default verify paths if it hasn't been told about any paths, even if
+        # the context itself was sometime earlier. We resolve that by just
+        # ignoring it.
+        pass
+
+    def load_default_certs(self):
+        return self.set_default_verify_paths()
+
+    def set_ciphers(self, ciphers):
+        # For now, we just require the default cipher string.
+        if ciphers != util.ssl_.DEFAULT_CIPHERS:
+            raise ValueError(
+                "SecureTransport doesn't support custom cipher strings"
+            )
+
+    def load_verify_locations(self, cafile=None, capath=None, cadata=None):
+        # OK, we only really support cadata and cafile.
+        if capath is not None:
+            raise ValueError(
+                "SecureTransport does not support cert directories"
+            )
+
+        self._trust_bundle = cafile or cadata
+
+    def load_cert_chain(self, certfile, keyfile=None, password=None):
+        self._client_cert = certfile
+        self._client_key = keyfile
+        self._client_cert_passphrase = password
+
+    def wrap_socket(self, sock, server_side=False,
+                    do_handshake_on_connect=True, suppress_ragged_eofs=True,
+                    server_hostname=None):
+        # So, what do we do here? Firstly, we assert some properties. This is a
+        # stripped down shim, so there is some functionality we don't support.
+        # See PEP 543 for the real deal.
+        assert not server_side
+        assert do_handshake_on_connect
+        assert suppress_ragged_eofs
+
+        # Ok, we're good to go. Now we want to create the wrapped socket object
+        # and store it in the appropriate place.
+        wrapped_socket = WrappedSocket(sock)
+
+        # Now we can handshake
+        wrapped_socket.handshake(
+            server_hostname, self._verify, self._trust_bundle,
+            self._min_version, self._max_version, self._client_cert,
+            self._client_key, self._client_key_passphrase
+        )
+        return wrapped_socket
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/socks.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/socks.py
new file mode 100644
index 0000000000000000000000000000000000000000..636d261fb0355e6b808da32f4676b9be2ebfb57a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/contrib/socks.py
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+"""
+This module contains provisional support for SOCKS proxies from within
+urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and
+SOCKS5. To enable its functionality, either install PySocks or install this
+module with the ``socks`` extra.
+
+The SOCKS implementation supports the full range of urllib3 features. It also
+supports the following SOCKS features:
+
+- SOCKS4A (``proxy_url='socks4a://...``)
+- SOCKS4 (``proxy_url='socks4://...``)
+- SOCKS5 with remote DNS (``proxy_url='socks5h://...``)
+- SOCKS5 with local DNS (``proxy_url='socks5://...``)
+- Usernames and passwords for the SOCKS proxy
+
+ .. note::
+    It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in
+    your ``proxy_url`` to ensure that DNS resolution is done from the remote
+    server instead of client-side when connecting to a domain name.
+
+SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5
+supports IPv4, IPv6, and domain names.
+
+When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url``
+will be sent as the ``userid`` section of the SOCKS request::
+
+    proxy_url="socks4a://<userid>@proxy-host"
+
+When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion
+of the ``proxy_url`` will be sent as the username/password to authenticate
+with the proxy::
+
+    proxy_url="socks5h://<username>:<password>@proxy-host"
+
+"""
+from __future__ import absolute_import
+
+try:
+    import socks
+except ImportError:
+    import warnings
+    from ..exceptions import DependencyWarning
+
+    warnings.warn((
+        'SOCKS support in urllib3 requires the installation of optional '
+        'dependencies: specifically, PySocks.  For more information, see '
+        'https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies'
+        ),
+        DependencyWarning
+    )
+    raise
+
+from socket import error as SocketError, timeout as SocketTimeout
+
+from ..connection import (
+    HTTPConnection, HTTPSConnection
+)
+from ..connectionpool import (
+    HTTPConnectionPool, HTTPSConnectionPool
+)
+from ..exceptions import ConnectTimeoutError, NewConnectionError
+from ..poolmanager import PoolManager
+from ..util.url import parse_url
+
+try:
+    import ssl
+except ImportError:
+    ssl = None
+
+
+class SOCKSConnection(HTTPConnection):
+    """
+    A plain-text HTTP connection that connects via a SOCKS proxy.
+    """
+    def __init__(self, *args, **kwargs):
+        self._socks_options = kwargs.pop('_socks_options')
+        super(SOCKSConnection, self).__init__(*args, **kwargs)
+
+    def _new_conn(self):
+        """
+        Establish a new connection via the SOCKS proxy.
+        """
+        extra_kw = {}
+        if self.source_address:
+            extra_kw['source_address'] = self.source_address
+
+        if self.socket_options:
+            extra_kw['socket_options'] = self.socket_options
+
+        try:
+            conn = socks.create_connection(
+                (self.host, self.port),
+                proxy_type=self._socks_options['socks_version'],
+                proxy_addr=self._socks_options['proxy_host'],
+                proxy_port=self._socks_options['proxy_port'],
+                proxy_username=self._socks_options['username'],
+                proxy_password=self._socks_options['password'],
+                proxy_rdns=self._socks_options['rdns'],
+                timeout=self.timeout,
+                **extra_kw
+            )
+
+        except SocketTimeout:
+            raise ConnectTimeoutError(
+                self, "Connection to %s timed out. (connect timeout=%s)" %
+                (self.host, self.timeout))
+
+        except socks.ProxyError as e:
+            # This is fragile as hell, but it seems to be the only way to raise
+            # useful errors here.
+            if e.socket_err:
+                error = e.socket_err
+                if isinstance(error, SocketTimeout):
+                    raise ConnectTimeoutError(
+                        self,
+                        "Connection to %s timed out. (connect timeout=%s)" %
+                        (self.host, self.timeout)
+                    )
+                else:
+                    raise NewConnectionError(
+                        self,
+                        "Failed to establish a new connection: %s" % error
+                    )
+            else:
+                raise NewConnectionError(
+                    self,
+                    "Failed to establish a new connection: %s" % e
+                )
+
+        except SocketError as e:  # Defensive: PySocks should catch all these.
+            raise NewConnectionError(
+                self, "Failed to establish a new connection: %s" % e)
+
+        return conn
+
+
+# We don't need to duplicate the Verified/Unverified distinction from
+# urllib3/connection.py here because the HTTPSConnection will already have been
+# correctly set to either the Verified or Unverified form by that module. This
+# means the SOCKSHTTPSConnection will automatically be the correct type.
+class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection):
+    pass
+
+
+class SOCKSHTTPConnectionPool(HTTPConnectionPool):
+    ConnectionCls = SOCKSConnection
+
+
+class SOCKSHTTPSConnectionPool(HTTPSConnectionPool):
+    ConnectionCls = SOCKSHTTPSConnection
+
+
+class SOCKSProxyManager(PoolManager):
+    """
+    A version of the urllib3 ProxyManager that routes connections via the
+    defined SOCKS proxy.
+    """
+    pool_classes_by_scheme = {
+        'http': SOCKSHTTPConnectionPool,
+        'https': SOCKSHTTPSConnectionPool,
+    }
+
+    def __init__(self, proxy_url, username=None, password=None,
+                 num_pools=10, headers=None, **connection_pool_kw):
+        parsed = parse_url(proxy_url)
+
+        if username is None and password is None and parsed.auth is not None:
+            split = parsed.auth.split(':')
+            if len(split) == 2:
+                username, password = split
+        if parsed.scheme == 'socks5':
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = False
+        elif parsed.scheme == 'socks5h':
+            socks_version = socks.PROXY_TYPE_SOCKS5
+            rdns = True
+        elif parsed.scheme == 'socks4':
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = False
+        elif parsed.scheme == 'socks4a':
+            socks_version = socks.PROXY_TYPE_SOCKS4
+            rdns = True
+        else:
+            raise ValueError(
+                "Unable to determine SOCKS version from %s" % proxy_url
+            )
+
+        self.proxy_url = proxy_url
+
+        socks_options = {
+            'socks_version': socks_version,
+            'proxy_host': parsed.host,
+            'proxy_port': parsed.port,
+            'username': username,
+            'password': password,
+            'rdns': rdns
+        }
+        connection_pool_kw['_socks_options'] = socks_options
+
+        super(SOCKSProxyManager, self).__init__(
+            num_pools, headers, **connection_pool_kw
+        )
+
+        self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..170e974c15746c3aa6e960d3c7a53981459a528d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/__init__.py
@@ -0,0 +1,5 @@
+from __future__ import absolute_import
+
+from . import ssl_match_hostname
+
+__all__ = ('ssl_match_hostname', )
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..371c6dd5193cfe224f744e49d8eb5a97d4f661a9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/__init__.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+An implementation of semantics and validations described in RFC 3986.
+
+See http://rfc3986.readthedocs.io/ for detailed documentation.
+
+:copyright: (c) 2014 Rackspace
+:license: Apache v2.0, see LICENSE for details
+"""
+
+from .api import iri_reference
+from .api import IRIReference
+from .api import is_valid_uri
+from .api import normalize_uri
+from .api import uri_reference
+from .api import URIReference
+from .api import urlparse
+from .parseresult import ParseResult
+
+__title__ = 'rfc3986'
+__author__ = 'Ian Stapleton Cordasco'
+__author_email__ = 'graffatcolmingov@gmail.com'
+__license__ = 'Apache v2.0'
+__copyright__ = 'Copyright 2014 Rackspace'
+__version__ = '1.3.2'
+
+__all__ = (
+    'ParseResult',
+    'URIReference',
+    'IRIReference',
+    'is_valid_uri',
+    'normalize_uri',
+    'uri_reference',
+    'iri_reference',
+    'urlparse',
+    '__title__',
+    '__author__',
+    '__author_email__',
+    '__license__',
+    '__copyright__',
+    '__version__',
+)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/_mixin.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/_mixin.py
new file mode 100644
index 0000000000000000000000000000000000000000..543925cdbc4db5e2159c30e8cd090b77c880769e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/_mixin.py
@@ -0,0 +1,353 @@
+"""Module containing the implementation of the URIMixin class."""
+import warnings
+
+from . import exceptions as exc
+from . import misc
+from . import normalizers
+from . import validators
+
+
+class URIMixin(object):
+    """Mixin with all shared methods for URIs and IRIs."""
+
+    __hash__ = tuple.__hash__
+
+    def authority_info(self):
+        """Return a dictionary with the ``userinfo``, ``host``, and ``port``.
+
+        If the authority is not valid, it will raise a
+        :class:`~rfc3986.exceptions.InvalidAuthority` Exception.
+
+        :returns:
+            ``{'userinfo': 'username:password', 'host': 'www.example.com',
+            'port': '80'}``
+        :rtype: dict
+        :raises rfc3986.exceptions.InvalidAuthority:
+            If the authority is not ``None`` and can not be parsed.
+        """
+        if not self.authority:
+            return {'userinfo': None, 'host': None, 'port': None}
+
+        match = self._match_subauthority()
+
+        if match is None:
+            # In this case, we have an authority that was parsed from the URI
+            # Reference, but it cannot be further parsed by our
+            # misc.SUBAUTHORITY_MATCHER. In this case it must not be a valid
+            # authority.
+            raise exc.InvalidAuthority(self.authority.encode(self.encoding))
+
+        # We had a match, now let's ensure that it is actually a valid host
+        # address if it is IPv4
+        matches = match.groupdict()
+        host = matches.get('host')
+
+        if (host and misc.IPv4_MATCHER.match(host) and not
+                validators.valid_ipv4_host_address(host)):
+            # If we have a host, it appears to be IPv4 and it does not have
+            # valid bytes, it is an InvalidAuthority.
+            raise exc.InvalidAuthority(self.authority.encode(self.encoding))
+
+        return matches
+
+    def _match_subauthority(self):
+        return misc.SUBAUTHORITY_MATCHER.match(self.authority)
+
+    @property
+    def host(self):
+        """If present, a string representing the host."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority['host']
+
+    @property
+    def port(self):
+        """If present, the port extracted from the authority."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority['port']
+
+    @property
+    def userinfo(self):
+        """If present, the userinfo extracted from the authority."""
+        try:
+            authority = self.authority_info()
+        except exc.InvalidAuthority:
+            return None
+        return authority['userinfo']
+
+    def is_absolute(self):
+        """Determine if this URI Reference is an absolute URI.
+
+        See http://tools.ietf.org/html/rfc3986#section-4.3 for explanation.
+
+        :returns: ``True`` if it is an absolute URI, ``False`` otherwise.
+        :rtype: bool
+        """
+        return bool(misc.ABSOLUTE_URI_MATCHER.match(self.unsplit()))
+
+    def is_valid(self, **kwargs):
+        """Determine if the URI is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param bool require_scheme: Set to ``True`` if you wish to require the
+            presence of the scheme component.
+        :param bool require_authority: Set to ``True`` if you wish to require
+            the presence of the authority component.
+        :param bool require_path: Set to ``True`` if you wish to require the
+            presence of the path component.
+        :param bool require_query: Set to ``True`` if you wish to require the
+            presence of the query component.
+        :param bool require_fragment: Set to ``True`` if you wish to require
+            the presence of the fragment component.
+        :returns: ``True`` if the URI is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        validators = [
+            (self.scheme_is_valid, kwargs.get('require_scheme', False)),
+            (self.authority_is_valid, kwargs.get('require_authority', False)),
+            (self.path_is_valid, kwargs.get('require_path', False)),
+            (self.query_is_valid, kwargs.get('require_query', False)),
+            (self.fragment_is_valid, kwargs.get('require_fragment', False)),
+            ]
+        return all(v(r) for v, r in validators)
+
+    def authority_is_valid(self, require=False):
+        """Determine if the authority component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param bool require:
+            Set to ``True`` to require the presence of this component.
+        :returns:
+            ``True`` if the authority is valid. ``False`` otherwise.
+        :rtype:
+            bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        try:
+            self.authority_info()
+        except exc.InvalidAuthority:
+            return False
+
+        return validators.authority_is_valid(
+            self.authority,
+            host=self.host,
+            require=require,
+        )
+
+    def scheme_is_valid(self, require=False):
+        """Determine if the scheme component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the scheme is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        return validators.scheme_is_valid(self.scheme, require)
+
+    def path_is_valid(self, require=False):
+        """Determine if the path component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the path is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        return validators.path_is_valid(self.path, require)
+
+    def query_is_valid(self, require=False):
+        """Determine if the query component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the :class:`~rfc3986.validators.Validator` object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the query is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        return validators.query_is_valid(self.query, require)
+
+    def fragment_is_valid(self, require=False):
+        """Determine if the fragment component is valid.
+
+        .. deprecated:: 1.1.0
+
+            Use the Validator object instead.
+
+        :param str require: Set to ``True`` to require the presence of this
+            component.
+        :returns: ``True`` if the fragment is valid. ``False`` otherwise.
+        :rtype: bool
+        """
+        warnings.warn("Please use rfc3986.validators.Validator instead. "
+                      "This method will be eventually removed.",
+                      DeprecationWarning)
+        return validators.fragment_is_valid(self.fragment, require)
+
+    def normalized_equality(self, other_ref):
+        """Compare this URIReference to another URIReference.
+
+        :param URIReference other_ref: (required), The reference with which
+            we're comparing.
+        :returns: ``True`` if the references are equal, ``False`` otherwise.
+        :rtype: bool
+        """
+        return tuple(self.normalize()) == tuple(other_ref.normalize())
+
+    def resolve_with(self, base_uri, strict=False):
+        """Use an absolute URI Reference to resolve this relative reference.
+
+        Assuming this is a relative reference that you would like to resolve,
+        use the provided base URI to resolve it.
+
+        See http://tools.ietf.org/html/rfc3986#section-5 for more information.
+
+        :param base_uri: Either a string or URIReference. It must be an
+            absolute URI or it will raise an exception.
+        :returns: A new URIReference which is the result of resolving this
+            reference using ``base_uri``.
+        :rtype: :class:`URIReference`
+        :raises rfc3986.exceptions.ResolutionError:
+            If the ``base_uri`` is not an absolute URI.
+        """
+        if not isinstance(base_uri, URIMixin):
+            base_uri = type(self).from_string(base_uri)
+
+        if not base_uri.is_absolute():
+            raise exc.ResolutionError(base_uri)
+
+        # This is optional per
+        # http://tools.ietf.org/html/rfc3986#section-5.2.1
+        base_uri = base_uri.normalize()
+
+        # The reference we're resolving
+        resolving = self
+
+        if not strict and resolving.scheme == base_uri.scheme:
+            resolving = resolving.copy_with(scheme=None)
+
+        # http://tools.ietf.org/html/rfc3986#page-32
+        if resolving.scheme is not None:
+            target = resolving.copy_with(
+                path=normalizers.normalize_path(resolving.path)
+            )
+        else:
+            if resolving.authority is not None:
+                target = resolving.copy_with(
+                    scheme=base_uri.scheme,
+                    path=normalizers.normalize_path(resolving.path)
+                )
+            else:
+                if resolving.path is None:
+                    if resolving.query is not None:
+                        query = resolving.query
+                    else:
+                        query = base_uri.query
+                    target = resolving.copy_with(
+                        scheme=base_uri.scheme,
+                        authority=base_uri.authority,
+                        path=base_uri.path,
+                        query=query
+                    )
+                else:
+                    if resolving.path.startswith('/'):
+                        path = normalizers.normalize_path(resolving.path)
+                    else:
+                        path = normalizers.normalize_path(
+                            misc.merge_paths(base_uri, resolving.path)
+                        )
+                    target = resolving.copy_with(
+                        scheme=base_uri.scheme,
+                        authority=base_uri.authority,
+                        path=path,
+                        query=resolving.query
+                    )
+        return target
+
+    def unsplit(self):
+        """Create a URI string from the components.
+
+        :returns: The URI Reference reconstituted as a string.
+        :rtype: str
+        """
+        # See http://tools.ietf.org/html/rfc3986#section-5.3
+        result_list = []
+        if self.scheme:
+            result_list.extend([self.scheme, ':'])
+        if self.authority:
+            result_list.extend(['//', self.authority])
+        if self.path:
+            result_list.append(self.path)
+        if self.query is not None:
+            result_list.extend(['?', self.query])
+        if self.fragment is not None:
+            result_list.extend(['#', self.fragment])
+        return ''.join(result_list)
+
+    def copy_with(self, scheme=misc.UseExisting, authority=misc.UseExisting,
+                  path=misc.UseExisting, query=misc.UseExisting,
+                  fragment=misc.UseExisting):
+        """Create a copy of this reference with the new components.
+
+        :param str scheme:
+            (optional) The scheme to use for the new reference.
+        :param str authority:
+            (optional) The authority to use for the new reference.
+        :param str path:
+            (optional) The path to use for the new reference.
+        :param str query:
+            (optional) The query to use for the new reference.
+        :param str fragment:
+            (optional) The fragment to use for the new reference.
+        :returns:
+            New URIReference with provided components.
+        :rtype:
+            URIReference
+        """
+        attributes = {
+            'scheme': scheme,
+            'authority': authority,
+            'path': path,
+            'query': query,
+            'fragment': fragment,
+        }
+        for key, value in list(attributes.items()):
+            if value is misc.UseExisting:
+                del attributes[key]
+        uri = self._replace(**attributes)
+        uri.encoding = self.encoding
+        return uri
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/builder.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..7934279995c8aa3aae7514399ea3ada2e51edfb1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/builder.py
@@ -0,0 +1,298 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2017 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the logic for the URIBuilder object."""
+from . import compat
+from . import normalizers
+from . import uri
+
+
+class URIBuilder(object):
+    """Object to aid in building up a URI Reference from parts.
+
+    .. note::
+
+        This object should be instantiated by the user, but it's recommended
+        that it is not provided with arguments. Instead, use the available
+        method to populate the fields.
+
+    """
+
+    def __init__(self, scheme=None, userinfo=None, host=None, port=None,
+                 path=None, query=None, fragment=None):
+        """Initialize our URI builder.
+
+        :param str scheme:
+            (optional)
+        :param str userinfo:
+            (optional)
+        :param str host:
+            (optional)
+        :param int port:
+            (optional)
+        :param str path:
+            (optional)
+        :param str query:
+            (optional)
+        :param str fragment:
+            (optional)
+        """
+        self.scheme = scheme
+        self.userinfo = userinfo
+        self.host = host
+        self.port = port
+        self.path = path
+        self.query = query
+        self.fragment = fragment
+
+    def __repr__(self):
+        """Provide a convenient view of our builder object."""
+        formatstr = ('URIBuilder(scheme={b.scheme}, userinfo={b.userinfo}, '
+                     'host={b.host}, port={b.port}, path={b.path}, '
+                     'query={b.query}, fragment={b.fragment})')
+        return formatstr.format(b=self)
+
+    def add_scheme(self, scheme):
+        """Add a scheme to our builder object.
+
+        After normalizing, this will generate a new URIBuilder instance with
+        the specified scheme and all other attributes the same.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_scheme('HTTPS')
+            URIBuilder(scheme='https', userinfo=None, host=None, port=None,
+                    path=None, query=None, fragment=None)
+
+        """
+        scheme = normalizers.normalize_scheme(scheme)
+        return URIBuilder(
+            scheme=scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_credentials(self, username, password):
+        """Add credentials as the userinfo portion of the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_credentials('root', 's3crete')
+            URIBuilder(scheme=None, userinfo='root:s3crete', host=None,
+                    port=None, path=None, query=None, fragment=None)
+
+            >>> URIBuilder().add_credentials('root', None)
+            URIBuilder(scheme=None, userinfo='root', host=None,
+                    port=None, path=None, query=None, fragment=None)
+        """
+        if username is None:
+            raise ValueError('Username cannot be None')
+        userinfo = normalizers.normalize_username(username)
+
+        if password is not None:
+            userinfo = '{}:{}'.format(
+                userinfo,
+                normalizers.normalize_password(password),
+            )
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_host(self, host):
+        """Add hostname to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_host('google.com')
+            URIBuilder(scheme=None, userinfo=None, host='google.com',
+                    port=None, path=None, query=None, fragment=None)
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=normalizers.normalize_host(host),
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_port(self, port):
+        """Add port to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_port(80)
+            URIBuilder(scheme=None, userinfo=None, host=None, port='80',
+                    path=None, query=None, fragment=None)
+
+            >>> URIBuilder().add_port(443)
+            URIBuilder(scheme=None, userinfo=None, host=None, port='443',
+                    path=None, query=None, fragment=None)
+
+        """
+        port_int = int(port)
+        if port_int < 0:
+            raise ValueError(
+                'ports are not allowed to be negative. You provided {}'.format(
+                    port_int,
+                )
+            )
+        if port_int > 65535:
+            raise ValueError(
+                'ports are not allowed to be larger than 65535. '
+                'You provided {}'.format(
+                    port_int,
+                )
+            )
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port='{}'.format(port_int),
+            path=self.path,
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_path(self, path):
+        """Add a path to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_path('sigmavirus24/rfc3985')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/sigmavirus24/rfc3986', query=None, fragment=None)
+
+            >>> URIBuilder().add_path('/checkout.php')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path='/checkout.php', query=None, fragment=None)
+
+        """
+        if not path.startswith('/'):
+            path = '/{}'.format(path)
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=normalizers.normalize_path(path),
+            query=self.query,
+            fragment=self.fragment,
+        )
+
+    def add_query_from(self, query_items):
+        """Generate and add a query a dictionary or list of tuples.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_query_from({'a': 'b c'})
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c', fragment=None)
+
+            >>> URIBuilder().add_query_from([('a', 'b c')])
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b+c', fragment=None)
+
+        """
+        query = normalizers.normalize_query(compat.urlencode(query_items))
+
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=query,
+            fragment=self.fragment,
+        )
+
+    def add_query(self, query):
+        """Add a pre-formated query string to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_query('a=b&c=d')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query='a=b&c=d', fragment=None)
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=normalizers.normalize_query(query),
+            fragment=self.fragment,
+        )
+
+    def add_fragment(self, fragment):
+        """Add a fragment to the URI.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_fragment('section-2.6.1')
+            URIBuilder(scheme=None, userinfo=None, host=None, port=None,
+                    path=None, query=None, fragment='section-2.6.1')
+
+        """
+        return URIBuilder(
+            scheme=self.scheme,
+            userinfo=self.userinfo,
+            host=self.host,
+            port=self.port,
+            path=self.path,
+            query=self.query,
+            fragment=normalizers.normalize_fragment(fragment),
+        )
+
+    def finalize(self):
+        """Create a URIReference from our builder.
+
+        .. code-block:: python
+
+            >>> URIBuilder().add_scheme('https').add_host('github.com'
+            ...     ).add_path('sigmavirus24/rfc3986').finalize().unsplit()
+            'https://github.com/sigmavirus24/rfc3986'
+
+            >>> URIBuilder().add_scheme('https').add_host('github.com'
+            ...     ).add_path('sigmavirus24/rfc3986').add_credentials(
+            ...     'sigmavirus24', 'not-re@l').finalize().unsplit()
+            'https://sigmavirus24:not-re%40l@github.com/sigmavirus24/rfc3986'
+
+        """
+        return uri.URIReference(
+            self.scheme,
+            normalizers.normalize_authority(
+                (self.userinfo, self.host, self.port)
+            ),
+            self.path,
+            self.query,
+            self.fragment,
+        )
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..8968c3843732361f61101be1f7d71020047c44c8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/compat.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Compatibility module for Python 2 and 3 support."""
+import sys
+
+try:
+    from urllib.parse import quote as urlquote
+except ImportError:  # Python 2.x
+    from urllib import quote as urlquote
+
+try:
+    from urllib.parse import urlencode
+except ImportError:  # Python 2.x
+    from urllib import urlencode
+
+__all__ = (
+    'to_bytes',
+    'to_str',
+    'urlquote',
+    'urlencode',
+)
+
+PY3 = (3, 0) <= sys.version_info < (4, 0)
+PY2 = (2, 6) <= sys.version_info < (2, 8)
+
+
+if PY3:
+    unicode = str  # Python 3.x
+
+
+def to_str(b, encoding='utf-8'):
+    """Ensure that b is text in the specified encoding."""
+    if hasattr(b, 'decode') and not isinstance(b, unicode):
+        b = b.decode(encoding)
+    return b
+
+
+def to_bytes(s, encoding='utf-8'):
+    """Ensure that s is converted to bytes from the encoding."""
+    if hasattr(s, 'encode') and not isinstance(s, bytes):
+        s = s.encode(encoding)
+    return s
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/exceptions.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..da8ca7cb1f395515fab2ffc3ab28250553d4e361
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/exceptions.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+"""Exceptions module for rfc3986."""
+
+from . import compat
+
+
+class RFC3986Exception(Exception):
+    """Base class for all rfc3986 exception classes."""
+
+    pass
+
+
+class InvalidAuthority(RFC3986Exception):
+    """Exception when the authority string is invalid."""
+
+    def __init__(self, authority):
+        """Initialize the exception with the invalid authority."""
+        super(InvalidAuthority, self).__init__(
+            u"The authority ({0}) is not valid.".format(
+                compat.to_str(authority)))
+
+
+class InvalidPort(RFC3986Exception):
+    """Exception when the port is invalid."""
+
+    def __init__(self, port):
+        """Initialize the exception with the invalid port."""
+        super(InvalidPort, self).__init__(
+            'The port ("{0}") is not valid.'.format(port))
+
+
+class ResolutionError(RFC3986Exception):
+    """Exception to indicate a failure to resolve a URI."""
+
+    def __init__(self, uri):
+        """Initialize the error with the failed URI."""
+        super(ResolutionError, self).__init__(
+            "{0} is not an absolute URI.".format(uri.unsplit()))
+
+
+class ValidationError(RFC3986Exception):
+    """Exception raised during Validation of a URI."""
+
+    pass
+
+
+class MissingComponentError(ValidationError):
+    """Exception raised when a required component is missing."""
+
+    def __init__(self, uri, *component_names):
+        """Initialize the error with the missing component name."""
+        verb = 'was'
+        if len(component_names) > 1:
+            verb = 'were'
+
+        self.uri = uri
+        self.components = sorted(component_names)
+        components = ', '.join(self.components)
+        super(MissingComponentError, self).__init__(
+            "{} {} required but missing".format(components, verb),
+            uri,
+            self.components,
+        )
+
+
+class UnpermittedComponentError(ValidationError):
+    """Exception raised when a component has an unpermitted value."""
+
+    def __init__(self, component_name, component_value, allowed_values):
+        """Initialize the error with the unpermitted component."""
+        super(UnpermittedComponentError, self).__init__(
+            "{} was required to be one of {!r} but was {!r}".format(
+                component_name, list(sorted(allowed_values)), component_value,
+            ),
+            component_name,
+            component_value,
+            allowed_values,
+        )
+        self.component_name = component_name
+        self.component_value = component_value
+        self.allowed_values = allowed_values
+
+
+class PasswordForbidden(ValidationError):
+    """Exception raised when a URL has a password in the userinfo section."""
+
+    def __init__(self, uri):
+        """Initialize the error with the URI that failed validation."""
+        unsplit = getattr(uri, 'unsplit', lambda: uri)
+        super(PasswordForbidden, self).__init__(
+            '"{}" contained a password when validation forbade it'.format(
+                unsplit()
+            )
+        )
+        self.uri = uri
+
+
+class InvalidComponentsError(ValidationError):
+    """Exception raised when one or more components are invalid."""
+
+    def __init__(self, uri, *component_names):
+        """Initialize the error with the invalid component name(s)."""
+        verb = 'was'
+        if len(component_names) > 1:
+            verb = 'were'
+
+        self.uri = uri
+        self.components = sorted(component_names)
+        components = ', '.join(self.components)
+        super(InvalidComponentsError, self).__init__(
+            "{} {} found to be invalid".format(components, verb),
+            uri,
+            self.components,
+        )
+
+
+class MissingDependencyError(RFC3986Exception):
+    """Exception raised when an IRI is encoded without the 'idna' module."""
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/iri.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/iri.py
new file mode 100644
index 0000000000000000000000000000000000000000..416cae4a715bf7fcde31348ffa08072b67c8e056
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/iri.py
@@ -0,0 +1,147 @@
+"""Module containing the implementation of the IRIReference class."""
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections import namedtuple
+
+from . import compat
+from . import exceptions
+from . import misc
+from . import normalizers
+from . import uri
+
+
+try:
+    from pip._vendor import idna
+except ImportError:  # pragma: no cover
+    idna = None
+
+
+class IRIReference(namedtuple('IRIReference', misc.URI_COMPONENTS),
+                   uri.URIMixin):
+    """Immutable object representing a parsed IRI Reference.
+
+    Can be encoded into an URIReference object via the procedure
+    specified in RFC 3987 Section 3.1
+
+     .. note::
+        The IRI submodule is a new interface and may possibly change in
+        the future. Check for changes to the interface when upgrading.
+    """
+
+    slots = ()
+
+    def __new__(cls, scheme, authority, path, query, fragment,
+                encoding='utf-8'):
+        """Create a new IRIReference."""
+        ref = super(IRIReference, cls).__new__(
+            cls,
+            scheme or None,
+            authority or None,
+            path or None,
+            query,
+            fragment)
+        ref.encoding = encoding
+        return ref
+
+    def __eq__(self, other):
+        """Compare this reference to another."""
+        other_ref = other
+        if isinstance(other, tuple):
+            other_ref = self.__class__(*other)
+        elif not isinstance(other, IRIReference):
+            try:
+                other_ref = self.__class__.from_string(other)
+            except TypeError:
+                raise TypeError(
+                    'Unable to compare {0}() to {1}()'.format(
+                        type(self).__name__, type(other).__name__))
+
+        # See http://tools.ietf.org/html/rfc3986#section-6.2
+        return tuple(self) == tuple(other_ref)
+
+    def _match_subauthority(self):
+        return misc.ISUBAUTHORITY_MATCHER.match(self.authority)
+
+    @classmethod
+    def from_string(cls, iri_string, encoding='utf-8'):
+        """Parse a IRI reference from the given unicode IRI string.
+
+        :param str iri_string: Unicode IRI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :returns: :class:`IRIReference` or subclass thereof
+        """
+        iri_string = compat.to_str(iri_string, encoding)
+
+        split_iri = misc.IRI_MATCHER.match(iri_string).groupdict()
+        return cls(
+            split_iri['scheme'], split_iri['authority'],
+            normalizers.encode_component(split_iri['path'], encoding),
+            normalizers.encode_component(split_iri['query'], encoding),
+            normalizers.encode_component(split_iri['fragment'], encoding),
+            encoding,
+        )
+
+    def encode(self, idna_encoder=None):  # noqa: C901
+        """Encode an IRIReference into a URIReference instance.
+
+        If the ``idna`` module is installed or the ``rfc3986[idna]``
+        extra is used then unicode characters in the IRI host
+        component will be encoded with IDNA2008.
+
+        :param idna_encoder:
+            Function that encodes each part of the host component
+            If not given will raise an exception if the IRI
+            contains a host component.
+        :rtype: uri.URIReference
+        :returns: A URI reference
+        """
+        authority = self.authority
+        if authority:
+            if idna_encoder is None:
+                if idna is None:  # pragma: no cover
+                    raise exceptions.MissingDependencyError(
+                        "Could not import the 'idna' module "
+                        "and the IRI hostname requires encoding"
+                    )
+
+                def idna_encoder(name):
+                    if any(ord(c) > 128 for c in name):
+                        try:
+                            return idna.encode(name.lower(),
+                                               strict=True,
+                                               std3_rules=True)
+                        except idna.IDNAError:
+                            raise exceptions.InvalidAuthority(self.authority)
+                    return name
+
+            authority = ""
+            if self.host:
+                authority = ".".join([compat.to_str(idna_encoder(part))
+                                      for part in self.host.split(".")])
+
+            if self.userinfo is not None:
+                authority = (normalizers.encode_component(
+                             self.userinfo, self.encoding) + '@' + authority)
+
+            if self.port is not None:
+                authority += ":" + str(self.port)
+
+        return uri.URIReference(self.scheme,
+                                authority,
+                                path=self.path,
+                                query=self.query,
+                                fragment=self.fragment,
+                                encoding=self.encoding)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/misc.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..b735e04402cbf303eea85887635bd458062b0d7b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/misc.py
@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Module containing compiled regular expressions and constants.
+
+This module contains important constants, patterns, and compiled regular
+expressions for parsing and validating URIs and their components.
+"""
+
+import re
+
+from . import abnf_regexp
+
+# These are enumerated for the named tuple used as a superclass of
+# URIReference
+URI_COMPONENTS = ['scheme', 'authority', 'path', 'query', 'fragment']
+
+important_characters = {
+    'generic_delimiters': abnf_regexp.GENERIC_DELIMITERS,
+    'sub_delimiters': abnf_regexp.SUB_DELIMITERS,
+    # We need to escape the '*' in this case
+    're_sub_delimiters': abnf_regexp.SUB_DELIMITERS_RE,
+    'unreserved_chars': abnf_regexp.UNRESERVED_CHARS,
+    # We need to escape the '-' in this case:
+    're_unreserved': abnf_regexp.UNRESERVED_RE,
+}
+
+# For details about delimiters and reserved characters, see:
+# http://tools.ietf.org/html/rfc3986#section-2.2
+GENERIC_DELIMITERS = abnf_regexp.GENERIC_DELIMITERS_SET
+SUB_DELIMITERS = abnf_regexp.SUB_DELIMITERS_SET
+RESERVED_CHARS = abnf_regexp.RESERVED_CHARS_SET
+# For details about unreserved characters, see:
+# http://tools.ietf.org/html/rfc3986#section-2.3
+UNRESERVED_CHARS = abnf_regexp.UNRESERVED_CHARS_SET
+NON_PCT_ENCODED = abnf_regexp.NON_PCT_ENCODED_SET
+
+URI_MATCHER = re.compile(abnf_regexp.URL_PARSING_RE)
+
+SUBAUTHORITY_MATCHER = re.compile((
+    '^(?:(?P<userinfo>{0})@)?'  # userinfo
+    '(?P<host>{1})'  # host
+    ':?(?P<port>{2})?$'  # port
+    ).format(abnf_regexp.USERINFO_RE,
+             abnf_regexp.HOST_PATTERN,
+             abnf_regexp.PORT_RE))
+
+
+HOST_MATCHER = re.compile('^' + abnf_regexp.HOST_RE + '$')
+IPv4_MATCHER = re.compile('^' + abnf_regexp.IPv4_RE + '$')
+IPv6_MATCHER = re.compile(r'^\[' + abnf_regexp.IPv6_ADDRZ_RFC4007_RE + r'\]$')
+
+# Used by host validator
+IPv6_NO_RFC4007_MATCHER = re.compile(r'^\[%s\]$' % (
+    abnf_regexp.IPv6_ADDRZ_RE
+))
+
+# Matcher used to validate path components
+PATH_MATCHER = re.compile(abnf_regexp.PATH_RE)
+
+
+# ##################################
+# Query and Fragment Matcher Section
+# ##################################
+
+QUERY_MATCHER = re.compile(abnf_regexp.QUERY_RE)
+
+FRAGMENT_MATCHER = QUERY_MATCHER
+
+# Scheme validation, see: http://tools.ietf.org/html/rfc3986#section-3.1
+SCHEME_MATCHER = re.compile('^{0}$'.format(abnf_regexp.SCHEME_RE))
+
+RELATIVE_REF_MATCHER = re.compile(r'^%s(\?%s)?(#%s)?$' % (
+    abnf_regexp.RELATIVE_PART_RE,
+    abnf_regexp.QUERY_RE,
+    abnf_regexp.FRAGMENT_RE,
+))
+
+# See http://tools.ietf.org/html/rfc3986#section-4.3
+ABSOLUTE_URI_MATCHER = re.compile(r'^%s:%s(\?%s)?$' % (
+    abnf_regexp.COMPONENT_PATTERN_DICT['scheme'],
+    abnf_regexp.HIER_PART_RE,
+    abnf_regexp.QUERY_RE[1:-1],
+))
+
+# ###############
+# IRIs / RFC 3987
+# ###############
+
+IRI_MATCHER = re.compile(abnf_regexp.URL_PARSING_RE, re.UNICODE)
+
+ISUBAUTHORITY_MATCHER = re.compile((
+    u'^(?:(?P<userinfo>{0})@)?'  # iuserinfo
+    u'(?P<host>{1})'  # ihost
+    u':?(?P<port>{2})?$'  # port
+    ).format(abnf_regexp.IUSERINFO_RE,
+             abnf_regexp.IHOST_RE,
+             abnf_regexp.PORT_RE), re.UNICODE)
+
+
+# Path merger as defined in http://tools.ietf.org/html/rfc3986#section-5.2.3
+def merge_paths(base_uri, relative_path):
+    """Merge a base URI's path with a relative URI's path."""
+    if base_uri.path is None and base_uri.authority is not None:
+        return '/' + relative_path
+    else:
+        path = base_uri.path or ''
+        index = path.rfind('/')
+        return path[:index] + '/' + relative_path
+
+
+UseExisting = object()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/normalizers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/normalizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2eb1bb36f744527fb7763eda552b9e773df8a47f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/normalizers.py
@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module with functions to normalize components."""
+import re
+
+from . import compat
+from . import misc
+
+
+def normalize_scheme(scheme):
+    """Normalize the scheme component."""
+    return scheme.lower()
+
+
+def normalize_authority(authority):
+    """Normalize an authority tuple to a string."""
+    userinfo, host, port = authority
+    result = ''
+    if userinfo:
+        result += normalize_percent_characters(userinfo) + '@'
+    if host:
+        result += normalize_host(host)
+    if port:
+        result += ':' + port
+    return result
+
+
+def normalize_username(username):
+    """Normalize a username to make it safe to include in userinfo."""
+    return compat.urlquote(username)
+
+
+def normalize_password(password):
+    """Normalize a password to make safe for userinfo."""
+    return compat.urlquote(password)
+
+
+def normalize_host(host):
+    """Normalize a host string."""
+    if misc.IPv6_MATCHER.match(host):
+        percent = host.find('%')
+        if percent != -1:
+            percent_25 = host.find('%25')
+
+            # Replace RFC 4007 IPv6 Zone ID delimiter '%' with '%25'
+            # from RFC 6874. If the host is '[<IPv6 addr>%25]' then we
+            # assume RFC 4007 and normalize to '[<IPV6 addr>%2525]'
+            if percent_25 == -1 or percent < percent_25 or \
+                    (percent == percent_25 and percent_25 == len(host) - 4):
+                host = host.replace('%', '%25', 1)
+
+            # Don't normalize the casing of the Zone ID
+            return host[:percent].lower() + host[percent:]
+
+    return host.lower()
+
+
+def normalize_path(path):
+    """Normalize the path string."""
+    if not path:
+        return path
+
+    path = normalize_percent_characters(path)
+    return remove_dot_segments(path)
+
+
+def normalize_query(query):
+    """Normalize the query string."""
+    if not query:
+        return query
+    return normalize_percent_characters(query)
+
+
+def normalize_fragment(fragment):
+    """Normalize the fragment string."""
+    if not fragment:
+        return fragment
+    return normalize_percent_characters(fragment)
+
+
+PERCENT_MATCHER = re.compile('%[A-Fa-f0-9]{2}')
+
+
+def normalize_percent_characters(s):
+    """All percent characters should be upper-cased.
+
+    For example, ``"%3afoo%DF%ab"`` should be turned into ``"%3Afoo%DF%AB"``.
+    """
+    matches = set(PERCENT_MATCHER.findall(s))
+    for m in matches:
+        if not m.isupper():
+            s = s.replace(m, m.upper())
+    return s
+
+
+def remove_dot_segments(s):
+    """Remove dot segments from the string.
+
+    See also Section 5.2.4 of :rfc:`3986`.
+    """
+    # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code
+    segments = s.split('/')  # Turn the path into a list of segments
+    output = []  # Initialize the variable to use to store output
+
+    for segment in segments:
+        # '.' is the current directory, so ignore it, it is superfluous
+        if segment == '.':
+            continue
+        # Anything other than '..', should be appended to the output
+        elif segment != '..':
+            output.append(segment)
+        # In this case segment == '..', if we can, we should pop the last
+        # element
+        elif output:
+            output.pop()
+
+    # If the path starts with '/' and the output is empty or the first string
+    # is non-empty
+    if s.startswith('/') and (not output or output[0]):
+        output.insert(0, '')
+
+    # If the path starts with '/.' or '/..' ensure we add one more empty
+    # string to add a trailing '/'
+    if s.endswith(('/.', '/..')):
+        output.append('')
+
+    return '/'.join(output)
+
+
+def encode_component(uri_component, encoding):
+    """Encode the specific component in the provided encoding."""
+    if uri_component is None:
+        return uri_component
+
+    # Try to see if the component we're encoding is already percent-encoded
+    # so we can skip all '%' characters but still encode all others.
+    percent_encodings = len(PERCENT_MATCHER.findall(
+                            compat.to_str(uri_component, encoding)))
+
+    uri_bytes = compat.to_bytes(uri_component, encoding)
+    is_percent_encoded = percent_encodings == uri_bytes.count(b'%')
+
+    encoded_uri = bytearray()
+
+    for i in range(0, len(uri_bytes)):
+        # Will return a single character bytestring on both Python 2 & 3
+        byte = uri_bytes[i:i+1]
+        byte_ord = ord(byte)
+        if ((is_percent_encoded and byte == b'%')
+                or (byte_ord < 128 and byte.decode() in misc.NON_PCT_ENCODED)):
+            encoded_uri.extend(byte)
+            continue
+        encoded_uri.extend('%{0:02x}'.format(byte_ord).encode().upper())
+
+    return encoded_uri.decode(encoding)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/parseresult.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/parseresult.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a7345669397b9d3d298812d8e3febc454506cac
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/parseresult.py
@@ -0,0 +1,385 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the urlparse compatibility logic."""
+from collections import namedtuple
+
+from . import compat
+from . import exceptions
+from . import misc
+from . import normalizers
+from . import uri
+
+__all__ = ('ParseResult', 'ParseResultBytes')
+
+PARSED_COMPONENTS = ('scheme', 'userinfo', 'host', 'port', 'path', 'query',
+                     'fragment')
+
+
+class ParseResultMixin(object):
+    def _generate_authority(self, attributes):
+        # I swear I did not align the comparisons below. That's just how they
+        # happened to align based on pep8 and attribute lengths.
+        userinfo, host, port = (attributes[p]
+                                for p in ('userinfo', 'host', 'port'))
+        if (self.userinfo != userinfo or
+                self.host != host or
+                self.port != port):
+            if port:
+                port = '{0}'.format(port)
+            return normalizers.normalize_authority(
+                (compat.to_str(userinfo, self.encoding),
+                 compat.to_str(host, self.encoding),
+                 port)
+            )
+        return self.authority
+
+    def geturl(self):
+        """Shim to match the standard library method."""
+        return self.unsplit()
+
+    @property
+    def hostname(self):
+        """Shim to match the standard library."""
+        return self.host
+
+    @property
+    def netloc(self):
+        """Shim to match the standard library."""
+        return self.authority
+
+    @property
+    def params(self):
+        """Shim to match the standard library."""
+        return self.query
+
+
+class ParseResult(namedtuple('ParseResult', PARSED_COMPONENTS),
+                  ParseResultMixin):
+    """Implementation of urlparse compatibility class.
+
+    This uses the URIReference logic to handle compatibility with the
+    urlparse.ParseResult class.
+    """
+
+    slots = ()
+
+    def __new__(cls, scheme, userinfo, host, port, path, query, fragment,
+                uri_ref, encoding='utf-8'):
+        """Create a new ParseResult."""
+        parse_result = super(ParseResult, cls).__new__(
+            cls,
+            scheme or None,
+            userinfo or None,
+            host,
+            port or None,
+            path or None,
+            query,
+            fragment)
+        parse_result.encoding = encoding
+        parse_result.reference = uri_ref
+        return parse_result
+
+    @classmethod
+    def from_parts(cls, scheme=None, userinfo=None, host=None, port=None,
+                   path=None, query=None, fragment=None, encoding='utf-8'):
+        """Create a ParseResult instance from its parts."""
+        authority = ''
+        if userinfo is not None:
+            authority += userinfo + '@'
+        if host is not None:
+            authority += host
+        if port is not None:
+            authority += ':{0}'.format(port)
+        uri_ref = uri.URIReference(scheme=scheme,
+                                   authority=authority,
+                                   path=path,
+                                   query=query,
+                                   fragment=fragment,
+                                   encoding=encoding).normalize()
+        userinfo, host, port = authority_from(uri_ref, strict=True)
+        return cls(scheme=uri_ref.scheme,
+                   userinfo=userinfo,
+                   host=host,
+                   port=port,
+                   path=uri_ref.path,
+                   query=uri_ref.query,
+                   fragment=uri_ref.fragment,
+                   uri_ref=uri_ref,
+                   encoding=encoding)
+
+    @classmethod
+    def from_string(cls, uri_string, encoding='utf-8', strict=True,
+                    lazy_normalize=True):
+        """Parse a URI from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :param bool strict: Parse strictly according to :rfc:`3986` if True.
+            If False, parse similarly to the standard library's urlparse
+            function.
+        :returns: :class:`ParseResult` or subclass thereof
+        """
+        reference = uri.URIReference.from_string(uri_string, encoding)
+        if not lazy_normalize:
+            reference = reference.normalize()
+        userinfo, host, port = authority_from(reference, strict)
+
+        return cls(scheme=reference.scheme,
+                   userinfo=userinfo,
+                   host=host,
+                   port=port,
+                   path=reference.path,
+                   query=reference.query,
+                   fragment=reference.fragment,
+                   uri_ref=reference,
+                   encoding=encoding)
+
+    @property
+    def authority(self):
+        """Return the normalized authority."""
+        return self.reference.authority
+
+    def copy_with(self, scheme=misc.UseExisting, userinfo=misc.UseExisting,
+                  host=misc.UseExisting, port=misc.UseExisting,
+                  path=misc.UseExisting, query=misc.UseExisting,
+                  fragment=misc.UseExisting):
+        """Create a copy of this instance replacing with specified parts."""
+        attributes = zip(PARSED_COMPONENTS,
+                         (scheme, userinfo, host, port, path, query, fragment))
+        attrs_dict = {}
+        for name, value in attributes:
+            if value is misc.UseExisting:
+                value = getattr(self, name)
+            attrs_dict[name] = value
+        authority = self._generate_authority(attrs_dict)
+        ref = self.reference.copy_with(scheme=attrs_dict['scheme'],
+                                       authority=authority,
+                                       path=attrs_dict['path'],
+                                       query=attrs_dict['query'],
+                                       fragment=attrs_dict['fragment'])
+        return ParseResult(uri_ref=ref, encoding=self.encoding, **attrs_dict)
+
+    def encode(self, encoding=None):
+        """Convert to an instance of ParseResultBytes."""
+        encoding = encoding or self.encoding
+        attrs = dict(
+            zip(PARSED_COMPONENTS,
+                (attr.encode(encoding) if hasattr(attr, 'encode') else attr
+                 for attr in self)))
+        return ParseResultBytes(
+            uri_ref=self.reference,
+            encoding=encoding,
+            **attrs
+        )
+
+    def unsplit(self, use_idna=False):
+        """Create a URI string from the components.
+
+        :returns: The parsed URI reconstituted as a string.
+        :rtype: str
+        """
+        parse_result = self
+        if use_idna and self.host:
+            hostbytes = self.host.encode('idna')
+            host = hostbytes.decode(self.encoding)
+            parse_result = self.copy_with(host=host)
+        return parse_result.reference.unsplit()
+
+
+class ParseResultBytes(namedtuple('ParseResultBytes', PARSED_COMPONENTS),
+                       ParseResultMixin):
+    """Compatibility shim for the urlparse.ParseResultBytes object."""
+
+    def __new__(cls, scheme, userinfo, host, port, path, query, fragment,
+                uri_ref, encoding='utf-8', lazy_normalize=True):
+        """Create a new ParseResultBytes instance."""
+        parse_result = super(ParseResultBytes, cls).__new__(
+            cls,
+            scheme or None,
+            userinfo or None,
+            host,
+            port or None,
+            path or None,
+            query or None,
+            fragment or None)
+        parse_result.encoding = encoding
+        parse_result.reference = uri_ref
+        parse_result.lazy_normalize = lazy_normalize
+        return parse_result
+
+    @classmethod
+    def from_parts(cls, scheme=None, userinfo=None, host=None, port=None,
+                   path=None, query=None, fragment=None, encoding='utf-8',
+                   lazy_normalize=True):
+        """Create a ParseResult instance from its parts."""
+        authority = ''
+        if userinfo is not None:
+            authority += userinfo + '@'
+        if host is not None:
+            authority += host
+        if port is not None:
+            authority += ':{0}'.format(int(port))
+        uri_ref = uri.URIReference(scheme=scheme,
+                                   authority=authority,
+                                   path=path,
+                                   query=query,
+                                   fragment=fragment,
+                                   encoding=encoding)
+        if not lazy_normalize:
+            uri_ref = uri_ref.normalize()
+        to_bytes = compat.to_bytes
+        userinfo, host, port = authority_from(uri_ref, strict=True)
+        return cls(scheme=to_bytes(scheme, encoding),
+                   userinfo=to_bytes(userinfo, encoding),
+                   host=to_bytes(host, encoding),
+                   port=port,
+                   path=to_bytes(path, encoding),
+                   query=to_bytes(query, encoding),
+                   fragment=to_bytes(fragment, encoding),
+                   uri_ref=uri_ref,
+                   encoding=encoding,
+                   lazy_normalize=lazy_normalize)
+
+    @classmethod
+    def from_string(cls, uri_string, encoding='utf-8', strict=True,
+                    lazy_normalize=True):
+        """Parse a URI from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :param bool strict: Parse strictly according to :rfc:`3986` if True.
+            If False, parse similarly to the standard library's urlparse
+            function.
+        :returns: :class:`ParseResultBytes` or subclass thereof
+        """
+        reference = uri.URIReference.from_string(uri_string, encoding)
+        if not lazy_normalize:
+            reference = reference.normalize()
+        userinfo, host, port = authority_from(reference, strict)
+
+        to_bytes = compat.to_bytes
+        return cls(scheme=to_bytes(reference.scheme, encoding),
+                   userinfo=to_bytes(userinfo, encoding),
+                   host=to_bytes(host, encoding),
+                   port=port,
+                   path=to_bytes(reference.path, encoding),
+                   query=to_bytes(reference.query, encoding),
+                   fragment=to_bytes(reference.fragment, encoding),
+                   uri_ref=reference,
+                   encoding=encoding,
+                   lazy_normalize=lazy_normalize)
+
+    @property
+    def authority(self):
+        """Return the normalized authority."""
+        return self.reference.authority.encode(self.encoding)
+
+    def copy_with(self, scheme=misc.UseExisting, userinfo=misc.UseExisting,
+                  host=misc.UseExisting, port=misc.UseExisting,
+                  path=misc.UseExisting, query=misc.UseExisting,
+                  fragment=misc.UseExisting, lazy_normalize=True):
+        """Create a copy of this instance replacing with specified parts."""
+        attributes = zip(PARSED_COMPONENTS,
+                         (scheme, userinfo, host, port, path, query, fragment))
+        attrs_dict = {}
+        for name, value in attributes:
+            if value is misc.UseExisting:
+                value = getattr(self, name)
+            if not isinstance(value, bytes) and hasattr(value, 'encode'):
+                value = value.encode(self.encoding)
+            attrs_dict[name] = value
+        authority = self._generate_authority(attrs_dict)
+        to_str = compat.to_str
+        ref = self.reference.copy_with(
+            scheme=to_str(attrs_dict['scheme'], self.encoding),
+            authority=to_str(authority, self.encoding),
+            path=to_str(attrs_dict['path'], self.encoding),
+            query=to_str(attrs_dict['query'], self.encoding),
+            fragment=to_str(attrs_dict['fragment'], self.encoding)
+        )
+        if not lazy_normalize:
+            ref = ref.normalize()
+        return ParseResultBytes(
+            uri_ref=ref,
+            encoding=self.encoding,
+            lazy_normalize=lazy_normalize,
+            **attrs_dict
+        )
+
+    def unsplit(self, use_idna=False):
+        """Create a URI bytes object from the components.
+
+        :returns: The parsed URI reconstituted as a string.
+        :rtype: bytes
+        """
+        parse_result = self
+        if use_idna and self.host:
+            # self.host is bytes, to encode to idna, we need to decode it
+            # first
+            host = self.host.decode(self.encoding)
+            hostbytes = host.encode('idna')
+            parse_result = self.copy_with(host=hostbytes)
+        if self.lazy_normalize:
+            parse_result = parse_result.copy_with(lazy_normalize=False)
+        uri = parse_result.reference.unsplit()
+        return uri.encode(self.encoding)
+
+
+def split_authority(authority):
+    # Initialize our expected return values
+    userinfo = host = port = None
+    # Initialize an extra var we may need to use
+    extra_host = None
+    # Set-up rest in case there is no userinfo portion
+    rest = authority
+
+    if '@' in authority:
+        userinfo, rest = authority.rsplit('@', 1)
+
+    # Handle IPv6 host addresses
+    if rest.startswith('['):
+        host, rest = rest.split(']', 1)
+        host += ']'
+
+    if ':' in rest:
+        extra_host, port = rest.split(':', 1)
+    elif not host and rest:
+        host = rest
+
+    if extra_host and not host:
+        host = extra_host
+
+    return userinfo, host, port
+
+
+def authority_from(reference, strict):
+    try:
+        subauthority = reference.authority_info()
+    except exceptions.InvalidAuthority:
+        if strict:
+            raise
+        userinfo, host, port = split_authority(reference.authority)
+    else:
+        # Thanks to Richard Barrell for this idea:
+        # https://twitter.com/0x2ba22e11/status/617338811975139328
+        userinfo, host, port = (subauthority.get(p)
+                                for p in ('userinfo', 'host', 'port'))
+
+    if port:
+        try:
+            port = int(port)
+        except ValueError:
+            raise exceptions.InvalidPort(port)
+    return userinfo, host, port
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/uri.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/uri.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1d71505e2a8b39567d420a3ce1bdbe45cf2bd36
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/uri.py
@@ -0,0 +1,153 @@
+"""Module containing the implementation of the URIReference class."""
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014 Rackspace
+# Copyright (c) 2015 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from collections import namedtuple
+
+from . import compat
+from . import misc
+from . import normalizers
+from ._mixin import URIMixin
+
+
+class URIReference(namedtuple('URIReference', misc.URI_COMPONENTS), URIMixin):
+    """Immutable object representing a parsed URI Reference.
+
+    .. note::
+
+        This class is not intended to be directly instantiated by the user.
+
+    This object exposes attributes for the following components of a
+    URI:
+
+    - scheme
+    - authority
+    - path
+    - query
+    - fragment
+
+    .. attribute:: scheme
+
+        The scheme that was parsed for the URI Reference. For example,
+        ``http``, ``https``, ``smtp``, ``imap``, etc.
+
+    .. attribute:: authority
+
+        Component of the URI that contains the user information, host,
+        and port sub-components. For example,
+        ``google.com``, ``127.0.0.1:5000``, ``username@[::1]``,
+        ``username:password@example.com:443``, etc.
+
+    .. attribute:: path
+
+        The path that was parsed for the given URI Reference. For example,
+        ``/``, ``/index.php``, etc.
+
+    .. attribute:: query
+
+        The query component for a given URI Reference. For example, ``a=b``,
+        ``a=b%20c``, ``a=b+c``, ``a=b,c=d,e=%20f``, etc.
+
+    .. attribute:: fragment
+
+        The fragment component of a URI. For example, ``section-3.1``.
+
+    This class also provides extra attributes for easier access to information
+    like the subcomponents of the authority component.
+
+    .. attribute:: userinfo
+
+        The user information parsed from the authority.
+
+    .. attribute:: host
+
+        The hostname, IPv4, or IPv6 adddres parsed from the authority.
+
+    .. attribute:: port
+
+        The port parsed from the authority.
+    """
+
+    slots = ()
+
+    def __new__(cls, scheme, authority, path, query, fragment,
+                encoding='utf-8'):
+        """Create a new URIReference."""
+        ref = super(URIReference, cls).__new__(
+            cls,
+            scheme or None,
+            authority or None,
+            path or None,
+            query,
+            fragment)
+        ref.encoding = encoding
+        return ref
+
+    __hash__ = tuple.__hash__
+
+    def __eq__(self, other):
+        """Compare this reference to another."""
+        other_ref = other
+        if isinstance(other, tuple):
+            other_ref = URIReference(*other)
+        elif not isinstance(other, URIReference):
+            try:
+                other_ref = URIReference.from_string(other)
+            except TypeError:
+                raise TypeError(
+                    'Unable to compare URIReference() to {0}()'.format(
+                        type(other).__name__))
+
+        # See http://tools.ietf.org/html/rfc3986#section-6.2
+        naive_equality = tuple(self) == tuple(other_ref)
+        return naive_equality or self.normalized_equality(other_ref)
+
+    def normalize(self):
+        """Normalize this reference as described in Section 6.2.2.
+
+        This is not an in-place normalization. Instead this creates a new
+        URIReference.
+
+        :returns: A new reference object with normalized components.
+        :rtype: URIReference
+        """
+        # See http://tools.ietf.org/html/rfc3986#section-6.2.2 for logic in
+        # this method.
+        return URIReference(normalizers.normalize_scheme(self.scheme or ''),
+                            normalizers.normalize_authority(
+                                (self.userinfo, self.host, self.port)),
+                            normalizers.normalize_path(self.path or ''),
+                            normalizers.normalize_query(self.query),
+                            normalizers.normalize_fragment(self.fragment),
+                            self.encoding)
+
+    @classmethod
+    def from_string(cls, uri_string, encoding='utf-8'):
+        """Parse a URI reference from the given unicode URI string.
+
+        :param str uri_string: Unicode URI to be parsed into a reference.
+        :param str encoding: The encoding of the string provided
+        :returns: :class:`URIReference` or subclass thereof
+        """
+        uri_string = compat.to_str(uri_string, encoding)
+
+        split_uri = misc.URI_MATCHER.match(uri_string).groupdict()
+        return cls(
+            split_uri['scheme'], split_uri['authority'],
+            normalizers.encode_component(split_uri['path'], encoding),
+            normalizers.encode_component(split_uri['query'], encoding),
+            normalizers.encode_component(split_uri['fragment'], encoding),
+            encoding,
+        )
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/validators.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/validators.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fc97215b1f3ec5b7d689848eee044f2d3d7dc02
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/rfc3986/validators.py
@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2017 Ian Stapleton Cordasco
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module containing the validation logic for rfc3986."""
+from . import exceptions
+from . import misc
+from . import normalizers
+
+
+class Validator(object):
+    """Object used to configure validation of all objects in rfc3986.
+
+    .. versionadded:: 1.0
+
+    Example usage::
+
+         >>> from rfc3986 import api, validators
+         >>> uri = api.uri_reference('https://github.com/')
+         >>> validator = validators.Validator().require_presence_of(
+         ...    'scheme', 'host', 'path',
+         ... ).allow_schemes(
+         ...    'http', 'https',
+         ... ).allow_hosts(
+         ...    '127.0.0.1', 'github.com',
+         ... )
+         >>> validator.validate(uri)
+         >>> invalid_uri = rfc3986.uri_reference('imap://mail.google.com')
+         >>> validator.validate(invalid_uri)
+         Traceback (most recent call last):
+         ...
+         rfc3986.exceptions.MissingComponentError: ('path was required but
+         missing', URIReference(scheme=u'imap', authority=u'mail.google.com',
+         path=None, query=None, fragment=None), ['path'])
+
+    """
+
+    COMPONENT_NAMES = frozenset([
+        'scheme',
+        'userinfo',
+        'host',
+        'port',
+        'path',
+        'query',
+        'fragment',
+    ])
+
+    def __init__(self):
+        """Initialize our default validations."""
+        self.allowed_schemes = set()
+        self.allowed_hosts = set()
+        self.allowed_ports = set()
+        self.allow_password = True
+        self.required_components = {
+            'scheme': False,
+            'userinfo': False,
+            'host': False,
+            'port': False,
+            'path': False,
+            'query': False,
+            'fragment': False,
+        }
+        self.validated_components = self.required_components.copy()
+
+    def allow_schemes(self, *schemes):
+        """Require the scheme to be one of the provided schemes.
+
+        .. versionadded:: 1.0
+
+        :param schemes:
+            Schemes, without ``://`` that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for scheme in schemes:
+            self.allowed_schemes.add(normalizers.normalize_scheme(scheme))
+        return self
+
+    def allow_hosts(self, *hosts):
+        """Require the host to be one of the provided hosts.
+
+        .. versionadded:: 1.0
+
+        :param hosts:
+            Hosts that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for host in hosts:
+            self.allowed_hosts.add(normalizers.normalize_host(host))
+        return self
+
+    def allow_ports(self, *ports):
+        """Require the port to be one of the provided ports.
+
+        .. versionadded:: 1.0
+
+        :param ports:
+            Ports that are allowed.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        for port in ports:
+            port_int = int(port, base=10)
+            if 0 <= port_int <= 65535:
+                self.allowed_ports.add(port)
+        return self
+
+    def allow_use_of_password(self):
+        """Allow passwords to be present in the URI.
+
+        .. versionadded:: 1.0
+
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        self.allow_password = True
+        return self
+
+    def forbid_use_of_password(self):
+        """Prevent passwords from being included in the URI.
+
+        .. versionadded:: 1.0
+
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        self.allow_password = False
+        return self
+
+    def check_validity_of(self, *components):
+        """Check the validity of the components provided.
+
+        This can be specified repeatedly.
+
+        .. versionadded:: 1.1
+
+        :param components:
+            Names of components from :attr:`Validator.COMPONENT_NAMES`.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        components = [c.lower() for c in components]
+        for component in components:
+            if component not in self.COMPONENT_NAMES:
+                raise ValueError(
+                    '"{}" is not a valid component'.format(component)
+                )
+        self.validated_components.update({
+            component: True for component in components
+        })
+        return self
+
+    def require_presence_of(self, *components):
+        """Require the components provided.
+
+        This can be specified repeatedly.
+
+        .. versionadded:: 1.0
+
+        :param components:
+            Names of components from :attr:`Validator.COMPONENT_NAMES`.
+        :returns:
+            The validator instance.
+        :rtype:
+            Validator
+        """
+        components = [c.lower() for c in components]
+        for component in components:
+            if component not in self.COMPONENT_NAMES:
+                raise ValueError(
+                    '"{}" is not a valid component'.format(component)
+                )
+        self.required_components.update({
+            component: True for component in components
+        })
+        return self
+
+    def validate(self, uri):
+        """Check a URI for conditions specified on this validator.
+
+        .. versionadded:: 1.0
+
+        :param uri:
+            Parsed URI to validate.
+        :type uri:
+            rfc3986.uri.URIReference
+        :raises MissingComponentError:
+            When a required component is missing.
+        :raises UnpermittedComponentError:
+            When a component is not one of those allowed.
+        :raises PasswordForbidden:
+            When a password is present in the userinfo component but is
+            not permitted by configuration.
+        :raises InvalidComponentsError:
+            When a component was found to be invalid.
+        """
+        if not self.allow_password:
+            check_password(uri)
+
+        required_components = [
+            component
+            for component, required in self.required_components.items()
+            if required
+        ]
+        validated_components = [
+            component
+            for component, required in self.validated_components.items()
+            if required
+        ]
+        if required_components:
+            ensure_required_components_exist(uri, required_components)
+        if validated_components:
+            ensure_components_are_valid(uri, validated_components)
+
+        ensure_one_of(self.allowed_schemes, uri, 'scheme')
+        ensure_one_of(self.allowed_hosts, uri, 'host')
+        ensure_one_of(self.allowed_ports, uri, 'port')
+
+
+def check_password(uri):
+    """Assert that there is no password present in the uri."""
+    userinfo = uri.userinfo
+    if not userinfo:
+        return
+    credentials = userinfo.split(':', 1)
+    if len(credentials) <= 1:
+        return
+    raise exceptions.PasswordForbidden(uri)
+
+
+def ensure_one_of(allowed_values, uri, attribute):
+    """Assert that the uri's attribute is one of the allowed values."""
+    value = getattr(uri, attribute)
+    if value is not None and allowed_values and value not in allowed_values:
+        raise exceptions.UnpermittedComponentError(
+            attribute, value, allowed_values,
+        )
+
+
+def ensure_required_components_exist(uri, required_components):
+    """Assert that all required components are present in the URI."""
+    missing_components = sorted([
+        component
+        for component in required_components
+        if getattr(uri, component) is None
+    ])
+    if missing_components:
+        raise exceptions.MissingComponentError(uri, *missing_components)
+
+
+def is_valid(value, matcher, require):
+    """Determine if a value is valid based on the provided matcher.
+
+    :param str value:
+        Value to validate.
+    :param matcher:
+        Compiled regular expression to use to validate the value.
+    :param require:
+        Whether or not the value is required.
+    """
+    if require:
+        return (value is not None
+                and matcher.match(value))
+
+    # require is False and value is not None
+    return value is None or matcher.match(value)
+
+
+def authority_is_valid(authority, host=None, require=False):
+    """Determine if the authority string is valid.
+
+    :param str authority:
+        The authority to validate.
+    :param str host:
+        (optional) The host portion of the authority to validate.
+    :param bool require:
+        (optional) Specify if authority must not be None.
+    :returns:
+        ``True`` if valid, ``False`` otherwise
+    :rtype:
+        bool
+    """
+    validated = is_valid(authority, misc.SUBAUTHORITY_MATCHER, require)
+    if validated and host is not None:
+        return host_is_valid(host, require)
+    return validated
+
+
+def host_is_valid(host, require=False):
+    """Determine if the host string is valid.
+
+    :param str host:
+        The host to validate.
+    :param bool require:
+        (optional) Specify if host must not be None.
+    :returns:
+        ``True`` if valid, ``False`` otherwise
+    :rtype:
+        bool
+    """
+    validated = is_valid(host, misc.HOST_MATCHER, require)
+    if validated and host is not None and misc.IPv4_MATCHER.match(host):
+        return valid_ipv4_host_address(host)
+    elif validated and host is not None and misc.IPv6_MATCHER.match(host):
+        return misc.IPv6_NO_RFC4007_MATCHER.match(host) is not None
+    return validated
+
+
+def scheme_is_valid(scheme, require=False):
+    """Determine if the scheme is valid.
+
+    :param str scheme:
+        The scheme string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a scheme.
+    :returns:
+        ``True`` if the scheme is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(scheme, misc.SCHEME_MATCHER, require)
+
+
+def path_is_valid(path, require=False):
+    """Determine if the path component is valid.
+
+    :param str path:
+        The path string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a path.
+    :returns:
+        ``True`` if the path is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(path, misc.PATH_MATCHER, require)
+
+
+def query_is_valid(query, require=False):
+    """Determine if the query component is valid.
+
+    :param str query:
+        The query string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a query.
+    :returns:
+        ``True`` if the query is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(query, misc.QUERY_MATCHER, require)
+
+
+def fragment_is_valid(fragment, require=False):
+    """Determine if the fragment component is valid.
+
+    :param str fragment:
+        The fragment string to validate.
+    :param bool require:
+        (optional) Set to ``True`` to require the presence of a fragment.
+    :returns:
+        ``True`` if the fragment is valid. ``False`` otherwise.
+    :rtype:
+        bool
+    """
+    return is_valid(fragment, misc.FRAGMENT_MATCHER, require)
+
+
+def valid_ipv4_host_address(host):
+    """Determine if the given host is a valid IPv4 address."""
+    # If the host exists, and it might be IPv4, check each byte in the
+    # address.
+    return all([0 <= int(byte, base=10) <= 255 for byte in host.split('.')])
+
+
+_COMPONENT_VALIDATORS = {
+    'scheme': scheme_is_valid,
+    'path': path_is_valid,
+    'query': query_is_valid,
+    'fragment': fragment_is_valid,
+}
+
+_SUBAUTHORITY_VALIDATORS = set(['userinfo', 'host', 'port'])
+
+
+def subauthority_component_is_valid(uri, component):
+    """Determine if the userinfo, host, and port are valid."""
+    try:
+        subauthority_dict = uri.authority_info()
+    except exceptions.InvalidAuthority:
+        return False
+
+    # If we can parse the authority into sub-components and we're not
+    # validating the port, we can assume it's valid.
+    if component == 'host':
+        return host_is_valid(subauthority_dict['host'])
+    elif component != 'port':
+        return True
+
+    try:
+        port = int(subauthority_dict['port'])
+    except TypeError:
+        # If the port wasn't provided it'll be None and int(None) raises a
+        # TypeError
+        return True
+
+    return (0 <= port <= 65535)
+
+
+def ensure_components_are_valid(uri, validated_components):
+    """Assert that all components are valid in the URI."""
+    invalid_components = set([])
+    for component in validated_components:
+        if component in _SUBAUTHORITY_VALIDATORS:
+            if not subauthority_component_is_valid(uri, component):
+                invalid_components.add(component)
+            # Python's peephole optimizer means that while this continue *is*
+            # actually executed, coverage.py cannot detect that. See also,
+            # https://bitbucket.org/ned/coveragepy/issues/198/continue-marked-as-not-covered
+            continue  # nocov: Python 2.7, 3.3, 3.4
+
+        validator = _COMPONENT_VALIDATORS[component]
+        if not validator(getattr(uri, component)):
+            invalid_components.add(component)
+
+    if invalid_components:
+        raise exceptions.InvalidComponentsError(uri, *invalid_components)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/six.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/six.py
new file mode 100644
index 0000000000000000000000000000000000000000..190c0239cd7d7af82a6e0cbc8d68053fa2e3dfaf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/six.py
@@ -0,0 +1,868 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2015 Benjamin Peterson
+#
+# 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.
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.10.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        if value is None:
+            value = tp()
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+if sys.version_info[:2] == (3, 2):
+    exec_("""def raise_from(value, from_value):
+    if from_value is None:
+        raise value
+    raise value from from_value
+""")
+elif sys.version_info[:2] > (3, 2):
+    exec_("""def raise_from(value, from_value):
+    raise value from from_value
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        def wrapper(f):
+            f = functools.wraps(wrapped, assigned, updated)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6594eb264d3bbe36b98209d77de55a806817751
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py
@@ -0,0 +1,19 @@
+import sys
+
+try:
+    # Our match_hostname function is the same as 3.5's, so we only want to
+    # import the match_hostname function if it's at least that good.
+    if sys.version_info < (3, 5):
+        raise ImportError("Fallback to vendored code")
+
+    from ssl import CertificateError, match_hostname
+except ImportError:
+    try:
+        # Backport of the function from a pypi module
+        from backports.ssl_match_hostname import CertificateError, match_hostname
+    except ImportError:
+        # Our vendored copy
+        from ._implementation import CertificateError, match_hostname
+
+# Not needed, but documenting what we provide.
+__all__ = ('CertificateError', 'match_hostname')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py
new file mode 100644
index 0000000000000000000000000000000000000000..970cf653e7f45f61936475f1b0bd368f1ddf4f8f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py
@@ -0,0 +1,156 @@
+"""The match_hostname() function from Python 3.3.3, essential when using SSL."""
+
+# Note: This file is under the PSF license as the code comes from the python
+# stdlib.   http://docs.python.org/3/license.html
+
+import re
+import sys
+
+# ipaddress has been backported to 2.6+ in pypi.  If it is installed on the
+# system, use it to handle IPAddress ServerAltnames (this was added in
+# python-3.5) otherwise only do DNS matching.  This allows
+# backports.ssl_match_hostname to continue to be used in Python 2.7.
+try:
+    from pip._vendor import ipaddress
+except ImportError:
+    ipaddress = None
+
+__version__ = '3.5.0.1'
+
+
+class CertificateError(ValueError):
+    pass
+
+
+def _dnsname_match(dn, hostname, max_wildcards=1):
+    """Matching according to RFC 6125, section 6.4.3
+
+    http://tools.ietf.org/html/rfc6125#section-6.4.3
+    """
+    pats = []
+    if not dn:
+        return False
+
+    # Ported from python3-syntax:
+    # leftmost, *remainder = dn.split(r'.')
+    parts = dn.split(r'.')
+    leftmost = parts[0]
+    remainder = parts[1:]
+
+    wildcards = leftmost.count('*')
+    if wildcards > max_wildcards:
+        # Issue #17980: avoid denials of service by refusing more
+        # than one wildcard per fragment.  A survey of established
+        # policy among SSL implementations showed it to be a
+        # reasonable choice.
+        raise CertificateError(
+            "too many wildcards in certificate DNS name: " + repr(dn))
+
+    # speed up common case w/o wildcards
+    if not wildcards:
+        return dn.lower() == hostname.lower()
+
+    # RFC 6125, section 6.4.3, subitem 1.
+    # The client SHOULD NOT attempt to match a presented identifier in which
+    # the wildcard character comprises a label other than the left-most label.
+    if leftmost == '*':
+        # When '*' is a fragment by itself, it matches a non-empty dotless
+        # fragment.
+        pats.append('[^.]+')
+    elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
+        # RFC 6125, section 6.4.3, subitem 3.
+        # The client SHOULD NOT attempt to match a presented identifier
+        # where the wildcard character is embedded within an A-label or
+        # U-label of an internationalized domain name.
+        pats.append(re.escape(leftmost))
+    else:
+        # Otherwise, '*' matches any dotless string, e.g. www*
+        pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
+
+    # add the remaining fragments, ignore any wildcards
+    for frag in remainder:
+        pats.append(re.escape(frag))
+
+    pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
+    return pat.match(hostname)
+
+
+def _to_unicode(obj):
+    if isinstance(obj, str) and sys.version_info < (3,):
+        obj = unicode(obj, encoding='ascii', errors='strict')
+    return obj
+
+def _ipaddress_match(ipname, host_ip):
+    """Exact matching of IP addresses.
+
+    RFC 6125 explicitly doesn't define an algorithm for this
+    (section 1.7.2 - "Out of Scope").
+    """
+    # OpenSSL may add a trailing newline to a subjectAltName's IP address
+    # Divergence from upstream: ipaddress can't handle byte str
+    ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())
+    return ip == host_ip
+
+
+def match_hostname(cert, hostname):
+    """Verify that *cert* (in decoded format as returned by
+    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
+    rules are followed, but IP addresses are not accepted for *hostname*.
+
+    CertificateError is raised on failure. On success, the function
+    returns nothing.
+    """
+    if not cert:
+        raise ValueError("empty or no certificate, match_hostname needs a "
+                         "SSL socket or SSL context with either "
+                         "CERT_OPTIONAL or CERT_REQUIRED")
+    try:
+        # Divergence from upstream: ipaddress can't handle byte str
+        host_ip = ipaddress.ip_address(_to_unicode(hostname))
+    except ValueError:
+        # Not an IP address (common case)
+        host_ip = None
+    except UnicodeError:
+        # Divergence from upstream: Have to deal with ipaddress not taking
+        # byte strings.  addresses should be all ascii, so we consider it not
+        # an ipaddress in this case
+        host_ip = None
+    except AttributeError:
+        # Divergence from upstream: Make ipaddress library optional
+        if ipaddress is None:
+            host_ip = None
+        else:
+            raise
+    dnsnames = []
+    san = cert.get('subjectAltName', ())
+    for key, value in san:
+        if key == 'DNS':
+            if host_ip is None and _dnsname_match(value, hostname):
+                return
+            dnsnames.append(value)
+        elif key == 'IP Address':
+            if host_ip is not None and _ipaddress_match(value, host_ip):
+                return
+            dnsnames.append(value)
+    if not dnsnames:
+        # The subject is only checked when there is no dNSName entry
+        # in subjectAltName
+        for sub in cert.get('subject', ()):
+            for key, value in sub:
+                # XXX according to RFC 2818, the most specific Common Name
+                # must be used.
+                if key == 'commonName':
+                    if _dnsname_match(value, hostname):
+                        return
+                    dnsnames.append(value)
+    if len(dnsnames) > 1:
+        raise CertificateError("hostname %r "
+            "doesn't match either of %s"
+            % (hostname, ', '.join(map(repr, dnsnames))))
+    elif len(dnsnames) == 1:
+        raise CertificateError("hostname %r "
+            "doesn't match %r"
+            % (hostname, dnsnames[0]))
+    else:
+        raise CertificateError("no appropriate commonName or "
+            "subjectAltName fields were found")
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/poolmanager.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/poolmanager.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6ade6e905629f48dadec33659251ddb574e7d5a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/poolmanager.py
@@ -0,0 +1,455 @@
+from __future__ import absolute_import
+import collections
+import functools
+import logging
+
+from ._collections import RecentlyUsedContainer
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+from .connectionpool import port_by_scheme
+from .exceptions import LocationValueError, MaxRetryError, ProxySchemeUnknown
+from .packages import six
+from .packages.six.moves.urllib.parse import urljoin
+from .request import RequestMethods
+from .util.url import parse_url
+from .util.retry import Retry
+
+
+__all__ = ['PoolManager', 'ProxyManager', 'proxy_from_url']
+
+
+log = logging.getLogger(__name__)
+
+SSL_KEYWORDS = ('key_file', 'cert_file', 'cert_reqs', 'ca_certs',
+                'ssl_version', 'ca_cert_dir', 'ssl_context',
+                'key_password')
+
+# All known keyword arguments that could be provided to the pool manager, its
+# pools, or the underlying connections. This is used to construct a pool key.
+_key_fields = (
+    'key_scheme',  # str
+    'key_host',  # str
+    'key_port',  # int
+    'key_timeout',  # int or float or Timeout
+    'key_retries',  # int or Retry
+    'key_strict',  # bool
+    'key_block',  # bool
+    'key_source_address',  # str
+    'key_key_file',  # str
+    'key_key_password',  # str
+    'key_cert_file',  # str
+    'key_cert_reqs',  # str
+    'key_ca_certs',  # str
+    'key_ssl_version',  # str
+    'key_ca_cert_dir',  # str
+    'key_ssl_context',  # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext
+    'key_maxsize',  # int
+    'key_headers',  # dict
+    'key__proxy',  # parsed proxy url
+    'key__proxy_headers',  # dict
+    'key_socket_options',  # list of (level (int), optname (int), value (int or str)) tuples
+    'key__socks_options',  # dict
+    'key_assert_hostname',  # bool or string
+    'key_assert_fingerprint',  # str
+    'key_server_hostname',  # str
+)
+
+#: The namedtuple class used to construct keys for the connection pool.
+#: All custom key schemes should include the fields in this key at a minimum.
+PoolKey = collections.namedtuple('PoolKey', _key_fields)
+
+
+def _default_key_normalizer(key_class, request_context):
+    """
+    Create a pool key out of a request context dictionary.
+
+    According to RFC 3986, both the scheme and host are case-insensitive.
+    Therefore, this function normalizes both before constructing the pool
+    key for an HTTPS request. If you wish to change this behaviour, provide
+    alternate callables to ``key_fn_by_scheme``.
+
+    :param key_class:
+        The class to use when constructing the key. This should be a namedtuple
+        with the ``scheme`` and ``host`` keys at a minimum.
+    :type  key_class: namedtuple
+    :param request_context:
+        A dictionary-like object that contain the context for a request.
+    :type  request_context: dict
+
+    :return: A namedtuple that can be used as a connection pool key.
+    :rtype:  PoolKey
+    """
+    # Since we mutate the dictionary, make a copy first
+    context = request_context.copy()
+    context['scheme'] = context['scheme'].lower()
+    context['host'] = context['host'].lower()
+
+    # These are both dictionaries and need to be transformed into frozensets
+    for key in ('headers', '_proxy_headers', '_socks_options'):
+        if key in context and context[key] is not None:
+            context[key] = frozenset(context[key].items())
+
+    # The socket_options key may be a list and needs to be transformed into a
+    # tuple.
+    socket_opts = context.get('socket_options')
+    if socket_opts is not None:
+        context['socket_options'] = tuple(socket_opts)
+
+    # Map the kwargs to the names in the namedtuple - this is necessary since
+    # namedtuples can't have fields starting with '_'.
+    for key in list(context.keys()):
+        context['key_' + key] = context.pop(key)
+
+    # Default to ``None`` for keys missing from the context
+    for field in key_class._fields:
+        if field not in context:
+            context[field] = None
+
+    return key_class(**context)
+
+
+#: A dictionary that maps a scheme to a callable that creates a pool key.
+#: This can be used to alter the way pool keys are constructed, if desired.
+#: Each PoolManager makes a copy of this dictionary so they can be configured
+#: globally here, or individually on the instance.
+key_fn_by_scheme = {
+    'http': functools.partial(_default_key_normalizer, PoolKey),
+    'https': functools.partial(_default_key_normalizer, PoolKey),
+}
+
+pool_classes_by_scheme = {
+    'http': HTTPConnectionPool,
+    'https': HTTPSConnectionPool,
+}
+
+
+class PoolManager(RequestMethods):
+    """
+    Allows for arbitrary requests while transparently keeping track of
+    necessary connection pools for you.
+
+    :param num_pools:
+        Number of connection pools to cache before discarding the least
+        recently used pool.
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+
+    :param \\**connection_pool_kw:
+        Additional parameters are used to create fresh
+        :class:`urllib3.connectionpool.ConnectionPool` instances.
+
+    Example::
+
+        >>> manager = PoolManager(num_pools=2)
+        >>> r = manager.request('GET', 'http://google.com/')
+        >>> r = manager.request('GET', 'http://google.com/mail')
+        >>> r = manager.request('GET', 'http://yahoo.com/')
+        >>> len(manager.pools)
+        2
+
+    """
+
+    proxy = None
+
+    def __init__(self, num_pools=10, headers=None, **connection_pool_kw):
+        RequestMethods.__init__(self, headers)
+        self.connection_pool_kw = connection_pool_kw
+        self.pools = RecentlyUsedContainer(num_pools,
+                                           dispose_func=lambda p: p.close())
+
+        # Locally set the pool classes and keys so other PoolManagers can
+        # override them.
+        self.pool_classes_by_scheme = pool_classes_by_scheme
+        self.key_fn_by_scheme = key_fn_by_scheme.copy()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.clear()
+        # Return False to re-raise any potential exceptions
+        return False
+
+    def _new_pool(self, scheme, host, port, request_context=None):
+        """
+        Create a new :class:`ConnectionPool` based on host, port, scheme, and
+        any additional pool keyword arguments.
+
+        If ``request_context`` is provided, it is provided as keyword arguments
+        to the pool class used. This method is used to actually create the
+        connection pools handed out by :meth:`connection_from_url` and
+        companion methods. It is intended to be overridden for customization.
+        """
+        pool_cls = self.pool_classes_by_scheme[scheme]
+        if request_context is None:
+            request_context = self.connection_pool_kw.copy()
+
+        # Although the context has everything necessary to create the pool,
+        # this function has historically only used the scheme, host, and port
+        # in the positional args. When an API change is acceptable these can
+        # be removed.
+        for key in ('scheme', 'host', 'port'):
+            request_context.pop(key, None)
+
+        if scheme == 'http':
+            for kw in SSL_KEYWORDS:
+                request_context.pop(kw, None)
+
+        return pool_cls(host, port, **request_context)
+
+    def clear(self):
+        """
+        Empty our store of pools and direct them all to close.
+
+        This will not affect in-flight connections, but they will not be
+        re-used after completion.
+        """
+        self.pools.clear()
+
+    def connection_from_host(self, host, port=None, scheme='http', pool_kwargs=None):
+        """
+        Get a :class:`ConnectionPool` based on the host, port, and scheme.
+
+        If ``port`` isn't given, it will be derived from the ``scheme`` using
+        ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is
+        provided, it is merged with the instance's ``connection_pool_kw``
+        variable and used to create the new connection pool, if one is
+        needed.
+        """
+
+        if not host:
+            raise LocationValueError("No host specified.")
+
+        request_context = self._merge_pool_kwargs(pool_kwargs)
+        request_context['scheme'] = scheme or 'http'
+        if not port:
+            port = port_by_scheme.get(request_context['scheme'].lower(), 80)
+        request_context['port'] = port
+        request_context['host'] = host
+
+        return self.connection_from_context(request_context)
+
+    def connection_from_context(self, request_context):
+        """
+        Get a :class:`ConnectionPool` based on the request context.
+
+        ``request_context`` must at least contain the ``scheme`` key and its
+        value must be a key in ``key_fn_by_scheme`` instance variable.
+        """
+        scheme = request_context['scheme'].lower()
+        pool_key_constructor = self.key_fn_by_scheme[scheme]
+        pool_key = pool_key_constructor(request_context)
+
+        return self.connection_from_pool_key(pool_key, request_context=request_context)
+
+    def connection_from_pool_key(self, pool_key, request_context=None):
+        """
+        Get a :class:`ConnectionPool` based on the provided pool key.
+
+        ``pool_key`` should be a namedtuple that only contains immutable
+        objects. At a minimum it must have the ``scheme``, ``host``, and
+        ``port`` fields.
+        """
+        with self.pools.lock:
+            # If the scheme, host, or port doesn't match existing open
+            # connections, open a new ConnectionPool.
+            pool = self.pools.get(pool_key)
+            if pool:
+                return pool
+
+            # Make a fresh ConnectionPool of the desired type
+            scheme = request_context['scheme']
+            host = request_context['host']
+            port = request_context['port']
+            pool = self._new_pool(scheme, host, port, request_context=request_context)
+            self.pools[pool_key] = pool
+
+        return pool
+
+    def connection_from_url(self, url, pool_kwargs=None):
+        """
+        Similar to :func:`urllib3.connectionpool.connection_from_url`.
+
+        If ``pool_kwargs`` is not provided and a new pool needs to be
+        constructed, ``self.connection_pool_kw`` is used to initialize
+        the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs``
+        is provided, it is used instead. Note that if a new pool does not
+        need to be created for the request, the provided ``pool_kwargs`` are
+        not used.
+        """
+        u = parse_url(url)
+        return self.connection_from_host(u.host, port=u.port, scheme=u.scheme,
+                                         pool_kwargs=pool_kwargs)
+
+    def _merge_pool_kwargs(self, override):
+        """
+        Merge a dictionary of override values for self.connection_pool_kw.
+
+        This does not modify self.connection_pool_kw and returns a new dict.
+        Any keys in the override dictionary with a value of ``None`` are
+        removed from the merged dictionary.
+        """
+        base_pool_kwargs = self.connection_pool_kw.copy()
+        if override:
+            for key, value in override.items():
+                if value is None:
+                    try:
+                        del base_pool_kwargs[key]
+                    except KeyError:
+                        pass
+                else:
+                    base_pool_kwargs[key] = value
+        return base_pool_kwargs
+
+    def urlopen(self, method, url, redirect=True, **kw):
+        """
+        Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen`
+        with custom cross-host redirect logic and only sends the request-uri
+        portion of the ``url``.
+
+        The given ``url`` parameter must be absolute, such that an appropriate
+        :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.
+        """
+        u = parse_url(url)
+        conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme)
+
+        kw['assert_same_host'] = False
+        kw['redirect'] = False
+
+        if 'headers' not in kw:
+            kw['headers'] = self.headers.copy()
+
+        if self.proxy is not None and u.scheme == "http":
+            response = conn.urlopen(method, url, **kw)
+        else:
+            response = conn.urlopen(method, u.request_uri, **kw)
+
+        redirect_location = redirect and response.get_redirect_location()
+        if not redirect_location:
+            return response
+
+        # Support relative URLs for redirecting.
+        redirect_location = urljoin(url, redirect_location)
+
+        # RFC 7231, Section 6.4.4
+        if response.status == 303:
+            method = 'GET'
+
+        retries = kw.get('retries')
+        if not isinstance(retries, Retry):
+            retries = Retry.from_int(retries, redirect=redirect)
+
+        # Strip headers marked as unsafe to forward to the redirected location.
+        # Check remove_headers_on_redirect to avoid a potential network call within
+        # conn.is_same_host() which may use socket.gethostbyname() in the future.
+        if (retries.remove_headers_on_redirect
+                and not conn.is_same_host(redirect_location)):
+            headers = list(six.iterkeys(kw['headers']))
+            for header in headers:
+                if header.lower() in retries.remove_headers_on_redirect:
+                    kw['headers'].pop(header, None)
+
+        try:
+            retries = retries.increment(method, url, response=response, _pool=conn)
+        except MaxRetryError:
+            if retries.raise_on_redirect:
+                raise
+            return response
+
+        kw['retries'] = retries
+        kw['redirect'] = redirect
+
+        log.info("Redirecting %s -> %s", url, redirect_location)
+        return self.urlopen(method, redirect_location, **kw)
+
+
+class ProxyManager(PoolManager):
+    """
+    Behaves just like :class:`PoolManager`, but sends all requests through
+    the defined proxy, using the CONNECT method for HTTPS URLs.
+
+    :param proxy_url:
+        The URL of the proxy to be used.
+
+    :param proxy_headers:
+        A dictionary containing headers that will be sent to the proxy. In case
+        of HTTP they are being sent with each request, while in the
+        HTTPS/CONNECT case they are sent only once. Could be used for proxy
+        authentication.
+
+    Example:
+        >>> proxy = urllib3.ProxyManager('http://localhost:3128/')
+        >>> r1 = proxy.request('GET', 'http://google.com/')
+        >>> r2 = proxy.request('GET', 'http://httpbin.org/')
+        >>> len(proxy.pools)
+        1
+        >>> r3 = proxy.request('GET', 'https://httpbin.org/')
+        >>> r4 = proxy.request('GET', 'https://twitter.com/')
+        >>> len(proxy.pools)
+        3
+
+    """
+
+    def __init__(self, proxy_url, num_pools=10, headers=None,
+                 proxy_headers=None, **connection_pool_kw):
+
+        if isinstance(proxy_url, HTTPConnectionPool):
+            proxy_url = '%s://%s:%i' % (proxy_url.scheme, proxy_url.host,
+                                        proxy_url.port)
+        proxy = parse_url(proxy_url)
+        if not proxy.port:
+            port = port_by_scheme.get(proxy.scheme, 80)
+            proxy = proxy._replace(port=port)
+
+        if proxy.scheme not in ("http", "https"):
+            raise ProxySchemeUnknown(proxy.scheme)
+
+        self.proxy = proxy
+        self.proxy_headers = proxy_headers or {}
+
+        connection_pool_kw['_proxy'] = self.proxy
+        connection_pool_kw['_proxy_headers'] = self.proxy_headers
+
+        super(ProxyManager, self).__init__(
+            num_pools, headers, **connection_pool_kw)
+
+    def connection_from_host(self, host, port=None, scheme='http', pool_kwargs=None):
+        if scheme == "https":
+            return super(ProxyManager, self).connection_from_host(
+                host, port, scheme, pool_kwargs=pool_kwargs)
+
+        return super(ProxyManager, self).connection_from_host(
+            self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs)
+
+    def _set_proxy_headers(self, url, headers=None):
+        """
+        Sets headers needed by proxies: specifically, the Accept and Host
+        headers. Only sets headers not provided by the user.
+        """
+        headers_ = {'Accept': '*/*'}
+
+        netloc = parse_url(url).netloc
+        if netloc:
+            headers_['Host'] = netloc
+
+        if headers:
+            headers_.update(headers)
+        return headers_
+
+    def urlopen(self, method, url, redirect=True, **kw):
+        "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute."
+        u = parse_url(url)
+
+        if u.scheme == "http":
+            # For proxied HTTPS requests, httplib sets the necessary headers
+            # on the CONNECT to the proxy. For HTTP, we'll definitely
+            # need to set 'Host' at the very least.
+            headers = kw.get('headers', self.headers)
+            kw['headers'] = self._set_proxy_headers(url, headers)
+
+        return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw)
+
+
+def proxy_from_url(url, **kw):
+    return ProxyManager(proxy_url=url, **kw)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/request.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/request.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f2f44bb2110a0017a0baa10aed5d8e175b7f7db
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/request.py
@@ -0,0 +1,150 @@
+from __future__ import absolute_import
+
+from .filepost import encode_multipart_formdata
+from .packages.six.moves.urllib.parse import urlencode
+
+
+__all__ = ['RequestMethods']
+
+
+class RequestMethods(object):
+    """
+    Convenience mixin for classes who implement a :meth:`urlopen` method, such
+    as :class:`~urllib3.connectionpool.HTTPConnectionPool` and
+    :class:`~urllib3.poolmanager.PoolManager`.
+
+    Provides behavior for making common types of HTTP request methods and
+    decides which type of request field encoding to use.
+
+    Specifically,
+
+    :meth:`.request_encode_url` is for sending requests whose fields are
+    encoded in the URL (such as GET, HEAD, DELETE).
+
+    :meth:`.request_encode_body` is for sending requests whose fields are
+    encoded in the *body* of the request using multipart or www-form-urlencoded
+    (such as for POST, PUT, PATCH).
+
+    :meth:`.request` is for making any kind of request, it will look up the
+    appropriate encoding format and use one of the above two methods to make
+    the request.
+
+    Initializer parameters:
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+    """
+
+    _encode_url_methods = {'DELETE', 'GET', 'HEAD', 'OPTIONS'}
+
+    def __init__(self, headers=None):
+        self.headers = headers or {}
+
+    def urlopen(self, method, url, body=None, headers=None,
+                encode_multipart=True, multipart_boundary=None,
+                **kw):  # Abstract
+        raise NotImplementedError("Classes extending RequestMethods must implement "
+                                  "their own ``urlopen`` method.")
+
+    def request(self, method, url, fields=None, headers=None, **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the appropriate encoding of
+        ``fields`` based on the ``method`` used.
+
+        This is a convenience method that requires the least amount of manual
+        effort. It can be used in most situations, while still having the
+        option to drop down to more specific methods when necessary, such as
+        :meth:`request_encode_url`, :meth:`request_encode_body`,
+        or even the lowest level :meth:`urlopen`.
+        """
+        method = method.upper()
+
+        urlopen_kw['request_url'] = url
+
+        if method in self._encode_url_methods:
+            return self.request_encode_url(method, url, fields=fields,
+                                           headers=headers,
+                                           **urlopen_kw)
+        else:
+            return self.request_encode_body(method, url, fields=fields,
+                                            headers=headers,
+                                            **urlopen_kw)
+
+    def request_encode_url(self, method, url, fields=None, headers=None,
+                           **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the url. This is useful for request methods like GET, HEAD, DELETE, etc.
+        """
+        if headers is None:
+            headers = self.headers
+
+        extra_kw = {'headers': headers}
+        extra_kw.update(urlopen_kw)
+
+        if fields:
+            url += '?' + urlencode(fields)
+
+        return self.urlopen(method, url, **extra_kw)
+
+    def request_encode_body(self, method, url, fields=None, headers=None,
+                            encode_multipart=True, multipart_boundary=None,
+                            **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the body. This is useful for request methods like POST, PUT, PATCH, etc.
+
+        When ``encode_multipart=True`` (default), then
+        :meth:`urllib3.filepost.encode_multipart_formdata` is used to encode
+        the payload with the appropriate content type. Otherwise
+        :meth:`urllib.urlencode` is used with the
+        'application/x-www-form-urlencoded' content type.
+
+        Multipart encoding must be used when posting files, and it's reasonably
+        safe to use it in other times too. However, it may break request
+        signing, such as with OAuth.
+
+        Supports an optional ``fields`` parameter of key/value strings AND
+        key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
+        the MIME type is optional. For example::
+
+            fields = {
+                'foo': 'bar',
+                'fakefile': ('foofile.txt', 'contents of foofile'),
+                'realfile': ('barfile.txt', open('realfile').read()),
+                'typedfile': ('bazfile.bin', open('bazfile').read(),
+                              'image/jpeg'),
+                'nonamefile': 'contents of nonamefile field',
+            }
+
+        When uploading a file, providing a filename (the first parameter of the
+        tuple) is optional but recommended to best mimic behavior of browsers.
+
+        Note that if ``headers`` are supplied, the 'Content-Type' header will
+        be overwritten because it depends on the dynamic random boundary string
+        which is used to compose the body of the request. The random boundary
+        string can be explicitly set with the ``multipart_boundary`` parameter.
+        """
+        if headers is None:
+            headers = self.headers
+
+        extra_kw = {'headers': {}}
+
+        if fields:
+            if 'body' in urlopen_kw:
+                raise TypeError(
+                    "request got values for both 'fields' and 'body', can only specify one.")
+
+            if encode_multipart:
+                body, content_type = encode_multipart_formdata(fields, boundary=multipart_boundary)
+            else:
+                body, content_type = urlencode(fields), 'application/x-www-form-urlencoded'
+
+            extra_kw['body'] = body
+            extra_kw['headers'] = {'Content-Type': content_type}
+
+        extra_kw['headers'].update(headers)
+        extra_kw.update(urlopen_kw)
+
+        return self.urlopen(method, url, **extra_kw)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/response.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/response.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f857932c54fdb069de457444d94699ba8b067d3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/response.py
@@ -0,0 +1,760 @@
+from __future__ import absolute_import
+from contextlib import contextmanager
+import zlib
+import io
+import logging
+from socket import timeout as SocketTimeout
+from socket import error as SocketError
+
+try:
+    import brotli
+except ImportError:
+    brotli = None
+
+from ._collections import HTTPHeaderDict
+from .exceptions import (
+    BodyNotHttplibCompatible, ProtocolError, DecodeError, ReadTimeoutError,
+    ResponseNotChunked, IncompleteRead, InvalidHeader
+)
+from .packages.six import string_types as basestring, PY3
+from .packages.six.moves import http_client as httplib
+from .connection import HTTPException, BaseSSLError
+from .util.response import is_fp_closed, is_response_to_head
+
+log = logging.getLogger(__name__)
+
+
+class DeflateDecoder(object):
+
+    def __init__(self):
+        self._first_try = True
+        self._data = b''
+        self._obj = zlib.decompressobj()
+
+    def __getattr__(self, name):
+        return getattr(self._obj, name)
+
+    def decompress(self, data):
+        if not data:
+            return data
+
+        if not self._first_try:
+            return self._obj.decompress(data)
+
+        self._data += data
+        try:
+            decompressed = self._obj.decompress(data)
+            if decompressed:
+                self._first_try = False
+                self._data = None
+            return decompressed
+        except zlib.error:
+            self._first_try = False
+            self._obj = zlib.decompressobj(-zlib.MAX_WBITS)
+            try:
+                return self.decompress(self._data)
+            finally:
+                self._data = None
+
+
+class GzipDecoderState(object):
+
+    FIRST_MEMBER = 0
+    OTHER_MEMBERS = 1
+    SWALLOW_DATA = 2
+
+
+class GzipDecoder(object):
+
+    def __init__(self):
+        self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
+        self._state = GzipDecoderState.FIRST_MEMBER
+
+    def __getattr__(self, name):
+        return getattr(self._obj, name)
+
+    def decompress(self, data):
+        ret = bytearray()
+        if self._state == GzipDecoderState.SWALLOW_DATA or not data:
+            return bytes(ret)
+        while True:
+            try:
+                ret += self._obj.decompress(data)
+            except zlib.error:
+                previous_state = self._state
+                # Ignore data after the first error
+                self._state = GzipDecoderState.SWALLOW_DATA
+                if previous_state == GzipDecoderState.OTHER_MEMBERS:
+                    # Allow trailing garbage acceptable in other gzip clients
+                    return bytes(ret)
+                raise
+            data = self._obj.unused_data
+            if not data:
+                return bytes(ret)
+            self._state = GzipDecoderState.OTHER_MEMBERS
+            self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
+
+
+if brotli is not None:
+    class BrotliDecoder(object):
+        # Supports both 'brotlipy' and 'Brotli' packages
+        # since they share an import name. The top branches
+        # are for 'brotlipy' and bottom branches for 'Brotli'
+        def __init__(self):
+            self._obj = brotli.Decompressor()
+
+        def decompress(self, data):
+            if hasattr(self._obj, 'decompress'):
+                return self._obj.decompress(data)
+            return self._obj.process(data)
+
+        def flush(self):
+            if hasattr(self._obj, 'flush'):
+                return self._obj.flush()
+            return b''
+
+
+class MultiDecoder(object):
+    """
+    From RFC7231:
+        If one or more encodings have been applied to a representation, the
+        sender that applied the encodings MUST generate a Content-Encoding
+        header field that lists the content codings in the order in which
+        they were applied.
+    """
+
+    def __init__(self, modes):
+        self._decoders = [_get_decoder(m.strip()) for m in modes.split(',')]
+
+    def flush(self):
+        return self._decoders[0].flush()
+
+    def decompress(self, data):
+        for d in reversed(self._decoders):
+            data = d.decompress(data)
+        return data
+
+
+def _get_decoder(mode):
+    if ',' in mode:
+        return MultiDecoder(mode)
+
+    if mode == 'gzip':
+        return GzipDecoder()
+
+    if brotli is not None and mode == 'br':
+        return BrotliDecoder()
+
+    return DeflateDecoder()
+
+
+class HTTPResponse(io.IOBase):
+    """
+    HTTP Response container.
+
+    Backwards-compatible to httplib's HTTPResponse but the response ``body`` is
+    loaded and decoded on-demand when the ``data`` property is accessed.  This
+    class is also compatible with the Python standard library's :mod:`io`
+    module, and can hence be treated as a readable object in the context of that
+    framework.
+
+    Extra parameters for behaviour not present in httplib.HTTPResponse:
+
+    :param preload_content:
+        If True, the response's body will be preloaded during construction.
+
+    :param decode_content:
+        If True, will attempt to decode the body based on the
+        'content-encoding' header.
+
+    :param original_response:
+        When this HTTPResponse wrapper is generated from an httplib.HTTPResponse
+        object, it's convenient to include the original for debug purposes. It's
+        otherwise unused.
+
+    :param retries:
+        The retries contains the last :class:`~urllib3.util.retry.Retry` that
+        was used during the request.
+
+    :param enforce_content_length:
+        Enforce content length checking. Body returned by server must match
+        value of Content-Length header, if present. Otherwise, raise error.
+    """
+
+    CONTENT_DECODERS = ['gzip', 'deflate']
+    if brotli is not None:
+        CONTENT_DECODERS += ['br']
+    REDIRECT_STATUSES = [301, 302, 303, 307, 308]
+
+    def __init__(self, body='', headers=None, status=0, version=0, reason=None,
+                 strict=0, preload_content=True, decode_content=True,
+                 original_response=None, pool=None, connection=None, msg=None,
+                 retries=None, enforce_content_length=False,
+                 request_method=None, request_url=None):
+
+        if isinstance(headers, HTTPHeaderDict):
+            self.headers = headers
+        else:
+            self.headers = HTTPHeaderDict(headers)
+        self.status = status
+        self.version = version
+        self.reason = reason
+        self.strict = strict
+        self.decode_content = decode_content
+        self.retries = retries
+        self.enforce_content_length = enforce_content_length
+
+        self._decoder = None
+        self._body = None
+        self._fp = None
+        self._original_response = original_response
+        self._fp_bytes_read = 0
+        self.msg = msg
+        self._request_url = request_url
+
+        if body and isinstance(body, (basestring, bytes)):
+            self._body = body
+
+        self._pool = pool
+        self._connection = connection
+
+        if hasattr(body, 'read'):
+            self._fp = body
+
+        # Are we using the chunked-style of transfer encoding?
+        self.chunked = False
+        self.chunk_left = None
+        tr_enc = self.headers.get('transfer-encoding', '').lower()
+        # Don't incur the penalty of creating a list and then discarding it
+        encodings = (enc.strip() for enc in tr_enc.split(","))
+        if "chunked" in encodings:
+            self.chunked = True
+
+        # Determine length of response
+        self.length_remaining = self._init_length(request_method)
+
+        # If requested, preload the body.
+        if preload_content and not self._body:
+            self._body = self.read(decode_content=decode_content)
+
+    def get_redirect_location(self):
+        """
+        Should we redirect and where to?
+
+        :returns: Truthy redirect location string if we got a redirect status
+            code and valid location. ``None`` if redirect status and no
+            location. ``False`` if not a redirect status code.
+        """
+        if self.status in self.REDIRECT_STATUSES:
+            return self.headers.get('location')
+
+        return False
+
+    def release_conn(self):
+        if not self._pool or not self._connection:
+            return
+
+        self._pool._put_conn(self._connection)
+        self._connection = None
+
+    @property
+    def data(self):
+        # For backwords-compat with earlier urllib3 0.4 and earlier.
+        if self._body:
+            return self._body
+
+        if self._fp:
+            return self.read(cache_content=True)
+
+    @property
+    def connection(self):
+        return self._connection
+
+    def isclosed(self):
+        return is_fp_closed(self._fp)
+
+    def tell(self):
+        """
+        Obtain the number of bytes pulled over the wire so far. May differ from
+        the amount of content returned by :meth:``HTTPResponse.read`` if bytes
+        are encoded on the wire (e.g, compressed).
+        """
+        return self._fp_bytes_read
+
+    def _init_length(self, request_method):
+        """
+        Set initial length value for Response content if available.
+        """
+        length = self.headers.get('content-length')
+
+        if length is not None:
+            if self.chunked:
+                # This Response will fail with an IncompleteRead if it can't be
+                # received as chunked. This method falls back to attempt reading
+                # the response before raising an exception.
+                log.warning("Received response with both Content-Length and "
+                            "Transfer-Encoding set. This is expressly forbidden "
+                            "by RFC 7230 sec 3.3.2. Ignoring Content-Length and "
+                            "attempting to process response as Transfer-Encoding: "
+                            "chunked.")
+                return None
+
+            try:
+                # RFC 7230 section 3.3.2 specifies multiple content lengths can
+                # be sent in a single Content-Length header
+                # (e.g. Content-Length: 42, 42). This line ensures the values
+                # are all valid ints and that as long as the `set` length is 1,
+                # all values are the same. Otherwise, the header is invalid.
+                lengths = set([int(val) for val in length.split(',')])
+                if len(lengths) > 1:
+                    raise InvalidHeader("Content-Length contained multiple "
+                                        "unmatching values (%s)" % length)
+                length = lengths.pop()
+            except ValueError:
+                length = None
+            else:
+                if length < 0:
+                    length = None
+
+        # Convert status to int for comparison
+        # In some cases, httplib returns a status of "_UNKNOWN"
+        try:
+            status = int(self.status)
+        except ValueError:
+            status = 0
+
+        # Check for responses that shouldn't include a body
+        if status in (204, 304) or 100 <= status < 200 or request_method == 'HEAD':
+            length = 0
+
+        return length
+
+    def _init_decoder(self):
+        """
+        Set-up the _decoder attribute if necessary.
+        """
+        # Note: content-encoding value should be case-insensitive, per RFC 7230
+        # Section 3.2
+        content_encoding = self.headers.get('content-encoding', '').lower()
+        if self._decoder is None:
+            if content_encoding in self.CONTENT_DECODERS:
+                self._decoder = _get_decoder(content_encoding)
+            elif ',' in content_encoding:
+                encodings = [
+                    e.strip() for e in content_encoding.split(',')
+                    if e.strip() in self.CONTENT_DECODERS]
+                if len(encodings):
+                    self._decoder = _get_decoder(content_encoding)
+
+    DECODER_ERROR_CLASSES = (IOError, zlib.error)
+    if brotli is not None:
+        DECODER_ERROR_CLASSES += (brotli.error,)
+
+    def _decode(self, data, decode_content, flush_decoder):
+        """
+        Decode the data passed in and potentially flush the decoder.
+        """
+        if not decode_content:
+            return data
+
+        try:
+            if self._decoder:
+                data = self._decoder.decompress(data)
+        except self.DECODER_ERROR_CLASSES as e:
+            content_encoding = self.headers.get('content-encoding', '').lower()
+            raise DecodeError(
+                "Received response with content-encoding: %s, but "
+                "failed to decode it." % content_encoding, e)
+        if flush_decoder:
+            data += self._flush_decoder()
+
+        return data
+
+    def _flush_decoder(self):
+        """
+        Flushes the decoder. Should only be called if the decoder is actually
+        being used.
+        """
+        if self._decoder:
+            buf = self._decoder.decompress(b'')
+            return buf + self._decoder.flush()
+
+        return b''
+
+    @contextmanager
+    def _error_catcher(self):
+        """
+        Catch low-level python exceptions, instead re-raising urllib3
+        variants, so that low-level exceptions are not leaked in the
+        high-level api.
+
+        On exit, release the connection back to the pool.
+        """
+        clean_exit = False
+
+        try:
+            try:
+                yield
+
+            except SocketTimeout:
+                # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but
+                # there is yet no clean way to get at it from this context.
+                raise ReadTimeoutError(self._pool, None, 'Read timed out.')
+
+            except BaseSSLError as e:
+                # FIXME: Is there a better way to differentiate between SSLErrors?
+                if 'read operation timed out' not in str(e):  # Defensive:
+                    # This shouldn't happen but just in case we're missing an edge
+                    # case, let's avoid swallowing SSL errors.
+                    raise
+
+                raise ReadTimeoutError(self._pool, None, 'Read timed out.')
+
+            except (HTTPException, SocketError) as e:
+                # This includes IncompleteRead.
+                raise ProtocolError('Connection broken: %r' % e, e)
+
+            # If no exception is thrown, we should avoid cleaning up
+            # unnecessarily.
+            clean_exit = True
+        finally:
+            # If we didn't terminate cleanly, we need to throw away our
+            # connection.
+            if not clean_exit:
+                # The response may not be closed but we're not going to use it
+                # anymore so close it now to ensure that the connection is
+                # released back to the pool.
+                if self._original_response:
+                    self._original_response.close()
+
+                # Closing the response may not actually be sufficient to close
+                # everything, so if we have a hold of the connection close that
+                # too.
+                if self._connection:
+                    self._connection.close()
+
+            # If we hold the original response but it's closed now, we should
+            # return the connection back to the pool.
+            if self._original_response and self._original_response.isclosed():
+                self.release_conn()
+
+    def read(self, amt=None, decode_content=None, cache_content=False):
+        """
+        Similar to :meth:`httplib.HTTPResponse.read`, but with two additional
+        parameters: ``decode_content`` and ``cache_content``.
+
+        :param amt:
+            How much of the content to read. If specified, caching is skipped
+            because it doesn't make sense to cache partial content as the full
+            response.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+
+        :param cache_content:
+            If True, will save the returned data such that the same result is
+            returned despite of the state of the underlying file object. This
+            is useful if you want the ``.data`` property to continue working
+            after having ``.read()`` the file object. (Overridden if ``amt`` is
+            set.)
+        """
+        self._init_decoder()
+        if decode_content is None:
+            decode_content = self.decode_content
+
+        if self._fp is None:
+            return
+
+        flush_decoder = False
+        data = None
+
+        with self._error_catcher():
+            if amt is None:
+                # cStringIO doesn't like amt=None
+                data = self._fp.read()
+                flush_decoder = True
+            else:
+                cache_content = False
+                data = self._fp.read(amt)
+                if amt != 0 and not data:  # Platform-specific: Buggy versions of Python.
+                    # Close the connection when no data is returned
+                    #
+                    # This is redundant to what httplib/http.client _should_
+                    # already do.  However, versions of python released before
+                    # December 15, 2012 (http://bugs.python.org/issue16298) do
+                    # not properly close the connection in all cases. There is
+                    # no harm in redundantly calling close.
+                    self._fp.close()
+                    flush_decoder = True
+                    if self.enforce_content_length and self.length_remaining not in (0, None):
+                        # This is an edge case that httplib failed to cover due
+                        # to concerns of backward compatibility. We're
+                        # addressing it here to make sure IncompleteRead is
+                        # raised during streaming, so all calls with incorrect
+                        # Content-Length are caught.
+                        raise IncompleteRead(self._fp_bytes_read, self.length_remaining)
+
+        if data:
+            self._fp_bytes_read += len(data)
+            if self.length_remaining is not None:
+                self.length_remaining -= len(data)
+
+            data = self._decode(data, decode_content, flush_decoder)
+
+            if cache_content:
+                self._body = data
+
+        return data
+
+    def stream(self, amt=2**16, decode_content=None):
+        """
+        A generator wrapper for the read() method. A call will block until
+        ``amt`` bytes have been read from the connection or until the
+        connection is closed.
+
+        :param amt:
+            How much of the content to read. The generator will return up to
+            much data per iteration, but may return less. This is particularly
+            likely when using compressed data. However, the empty string will
+            never be returned.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        if self.chunked and self.supports_chunked_reads():
+            for line in self.read_chunked(amt, decode_content=decode_content):
+                yield line
+        else:
+            while not is_fp_closed(self._fp):
+                data = self.read(amt=amt, decode_content=decode_content)
+
+                if data:
+                    yield data
+
+    @classmethod
+    def from_httplib(ResponseCls, r, **response_kw):
+        """
+        Given an :class:`httplib.HTTPResponse` instance ``r``, return a
+        corresponding :class:`urllib3.response.HTTPResponse` object.
+
+        Remaining parameters are passed to the HTTPResponse constructor, along
+        with ``original_response=r``.
+        """
+        headers = r.msg
+
+        if not isinstance(headers, HTTPHeaderDict):
+            if PY3:
+                headers = HTTPHeaderDict(headers.items())
+            else:
+                # Python 2.7
+                headers = HTTPHeaderDict.from_httplib(headers)
+
+        # HTTPResponse objects in Python 3 don't have a .strict attribute
+        strict = getattr(r, 'strict', 0)
+        resp = ResponseCls(body=r,
+                           headers=headers,
+                           status=r.status,
+                           version=r.version,
+                           reason=r.reason,
+                           strict=strict,
+                           original_response=r,
+                           **response_kw)
+        return resp
+
+    # Backwards-compatibility methods for httplib.HTTPResponse
+    def getheaders(self):
+        return self.headers
+
+    def getheader(self, name, default=None):
+        return self.headers.get(name, default)
+
+    # Backwards compatibility for http.cookiejar
+    def info(self):
+        return self.headers
+
+    # Overrides from io.IOBase
+    def close(self):
+        if not self.closed:
+            self._fp.close()
+
+        if self._connection:
+            self._connection.close()
+
+    @property
+    def closed(self):
+        if self._fp is None:
+            return True
+        elif hasattr(self._fp, 'isclosed'):
+            return self._fp.isclosed()
+        elif hasattr(self._fp, 'closed'):
+            return self._fp.closed
+        else:
+            return True
+
+    def fileno(self):
+        if self._fp is None:
+            raise IOError("HTTPResponse has no file to get a fileno from")
+        elif hasattr(self._fp, "fileno"):
+            return self._fp.fileno()
+        else:
+            raise IOError("The file-like object this HTTPResponse is wrapped "
+                          "around has no file descriptor")
+
+    def flush(self):
+        if self._fp is not None and hasattr(self._fp, 'flush'):
+            return self._fp.flush()
+
+    def readable(self):
+        # This method is required for `io` module compatibility.
+        return True
+
+    def readinto(self, b):
+        # This method is required for `io` module compatibility.
+        temp = self.read(len(b))
+        if len(temp) == 0:
+            return 0
+        else:
+            b[:len(temp)] = temp
+            return len(temp)
+
+    def supports_chunked_reads(self):
+        """
+        Checks if the underlying file-like object looks like a
+        httplib.HTTPResponse object. We do this by testing for the fp
+        attribute. If it is present we assume it returns raw chunks as
+        processed by read_chunked().
+        """
+        return hasattr(self._fp, 'fp')
+
+    def _update_chunk_length(self):
+        # First, we'll figure out length of a chunk and then
+        # we'll try to read it from socket.
+        if self.chunk_left is not None:
+            return
+        line = self._fp.fp.readline()
+        line = line.split(b';', 1)[0]
+        try:
+            self.chunk_left = int(line, 16)
+        except ValueError:
+            # Invalid chunked protocol response, abort.
+            self.close()
+            raise httplib.IncompleteRead(line)
+
+    def _handle_chunk(self, amt):
+        returned_chunk = None
+        if amt is None:
+            chunk = self._fp._safe_read(self.chunk_left)
+            returned_chunk = chunk
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+        elif amt < self.chunk_left:
+            value = self._fp._safe_read(amt)
+            self.chunk_left = self.chunk_left - amt
+            returned_chunk = value
+        elif amt == self.chunk_left:
+            value = self._fp._safe_read(amt)
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+            returned_chunk = value
+        else:  # amt > self.chunk_left
+            returned_chunk = self._fp._safe_read(self.chunk_left)
+            self._fp._safe_read(2)  # Toss the CRLF at the end of the chunk.
+            self.chunk_left = None
+        return returned_chunk
+
+    def read_chunked(self, amt=None, decode_content=None):
+        """
+        Similar to :meth:`HTTPResponse.read`, but with an additional
+        parameter: ``decode_content``.
+
+        :param amt:
+            How much of the content to read. If specified, caching is skipped
+            because it doesn't make sense to cache partial content as the full
+            response.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header.
+        """
+        self._init_decoder()
+        # FIXME: Rewrite this method and make it a class with a better structured logic.
+        if not self.chunked:
+            raise ResponseNotChunked(
+                "Response is not chunked. "
+                "Header 'transfer-encoding: chunked' is missing.")
+        if not self.supports_chunked_reads():
+            raise BodyNotHttplibCompatible(
+                "Body should be httplib.HTTPResponse like. "
+                "It should have have an fp attribute which returns raw chunks.")
+
+        with self._error_catcher():
+            # Don't bother reading the body of a HEAD request.
+            if self._original_response and is_response_to_head(self._original_response):
+                self._original_response.close()
+                return
+
+            # If a response is already read and closed
+            # then return immediately.
+            if self._fp.fp is None:
+                return
+
+            while True:
+                self._update_chunk_length()
+                if self.chunk_left == 0:
+                    break
+                chunk = self._handle_chunk(amt)
+                decoded = self._decode(chunk, decode_content=decode_content,
+                                       flush_decoder=False)
+                if decoded:
+                    yield decoded
+
+            if decode_content:
+                # On CPython and PyPy, we should never need to flush the
+                # decoder. However, on Jython we *might* need to, so
+                # lets defensively do it anyway.
+                decoded = self._flush_decoder()
+                if decoded:  # Platform-specific: Jython.
+                    yield decoded
+
+            # Chunk content ends with \r\n: discard it.
+            while True:
+                line = self._fp.fp.readline()
+                if not line:
+                    # Some sites may not end with '\r\n'.
+                    break
+                if line == b'\r\n':
+                    break
+
+            # We read everything; close the "file".
+            if self._original_response:
+                self._original_response.close()
+
+    def geturl(self):
+        """
+        Returns the URL that was the source of this response.
+        If the request that generated this response redirected, this method
+        will return the final redirect location.
+        """
+        if self.retries is not None and len(self.retries.history):
+            return self.retries.history[-1].redirect_location
+        else:
+            return self._request_url
+
+    def __iter__(self):
+        buffer = [b""]
+        for chunk in self.stream(decode_content=True):
+            if b"\n" in chunk:
+                chunk = chunk.split(b"\n")
+                yield b"".join(buffer) + chunk[0] + b"\n"
+                for x in chunk[1:-1]:
+                    yield x + b"\n"
+                if chunk[-1]:
+                    buffer = [chunk[-1]]
+                else:
+                    buffer = []
+            else:
+                buffer.append(chunk)
+        if buffer:
+            yield b"".join(buffer)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ad70b2f1ca8e575088626a345fd66fc3746f99c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.py
@@ -0,0 +1,134 @@
+from __future__ import absolute_import
+import socket
+from .wait import NoWayToWaitForSocketError, wait_for_read
+from ..contrib import _appengine_environ
+
+
+def is_connection_dropped(conn):  # Platform-specific
+    """
+    Returns True if the connection is dropped and should be closed.
+
+    :param conn:
+        :class:`httplib.HTTPConnection` object.
+
+    Note: For platforms like AppEngine, this will always return ``False`` to
+    let the platform handle connection recycling transparently for us.
+    """
+    sock = getattr(conn, 'sock', False)
+    if sock is False:  # Platform-specific: AppEngine
+        return False
+    if sock is None:  # Connection already closed (such as by httplib).
+        return True
+    try:
+        # Returns True if readable, which here means it's been dropped
+        return wait_for_read(sock, timeout=0.0)
+    except NoWayToWaitForSocketError:  # Platform-specific: AppEngine
+        return False
+
+
+# This function is copied from socket.py in the Python 2.7 standard
+# library test suite. Added to its signature is only `socket_options`.
+# One additional modification is that we avoid binding to IPv6 servers
+# discovered in DNS if the system doesn't have IPv6 functionality.
+def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
+                      source_address=None, socket_options=None):
+    """Connect to *address* and return the socket object.
+
+    Convenience function.  Connect to *address* (a 2-tuple ``(host,
+    port)``) and return the socket object.  Passing the optional
+    *timeout* parameter will set the timeout on the socket instance
+    before attempting to connect.  If no *timeout* is supplied, the
+    global default timeout setting returned by :func:`getdefaulttimeout`
+    is used.  If *source_address* is set it must be a tuple of (host, port)
+    for the socket to bind as a source address before making the connection.
+    An host of '' or port 0 tells the OS to use the default.
+    """
+
+    host, port = address
+    if host.startswith('['):
+        host = host.strip('[]')
+    err = None
+
+    # Using the value from allowed_gai_family() in the context of getaddrinfo lets
+    # us select whether to work with IPv4 DNS records, IPv6 records, or both.
+    # The original create_connection function always returns all records.
+    family = allowed_gai_family()
+
+    for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):
+        af, socktype, proto, canonname, sa = res
+        sock = None
+        try:
+            sock = socket.socket(af, socktype, proto)
+
+            # If provided, set socket level options before connecting.
+            _set_socket_options(sock, socket_options)
+
+            if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
+                sock.settimeout(timeout)
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sa)
+            return sock
+
+        except socket.error as e:
+            err = e
+            if sock is not None:
+                sock.close()
+                sock = None
+
+    if err is not None:
+        raise err
+
+    raise socket.error("getaddrinfo returns an empty list")
+
+
+def _set_socket_options(sock, options):
+    if options is None:
+        return
+
+    for opt in options:
+        sock.setsockopt(*opt)
+
+
+def allowed_gai_family():
+    """This function is designed to work in the context of
+    getaddrinfo, where family=socket.AF_UNSPEC is the default and
+    will perform a DNS search for both IPv6 and IPv4 records."""
+
+    family = socket.AF_INET
+    if HAS_IPV6:
+        family = socket.AF_UNSPEC
+    return family
+
+
+def _has_ipv6(host):
+    """ Returns True if the system can bind an IPv6 address. """
+    sock = None
+    has_ipv6 = False
+
+    # App Engine doesn't support IPV6 sockets and actually has a quota on the
+    # number of sockets that can be used, so just early out here instead of
+    # creating a socket needlessly.
+    # See https://github.com/urllib3/urllib3/issues/1446
+    if _appengine_environ.is_appengine_sandbox():
+        return False
+
+    if socket.has_ipv6:
+        # has_ipv6 returns true if cPython was compiled with IPv6 support.
+        # It does not tell us if the system has IPv6 support enabled. To
+        # determine that we must bind to an IPv6 address.
+        # https://github.com/shazow/urllib3/pull/611
+        # https://bugs.python.org/issue658327
+        try:
+            sock = socket.socket(socket.AF_INET6)
+            sock.bind((host, 0))
+            has_ipv6 = True
+        except Exception:
+            pass
+
+    if sock:
+        sock.close()
+    return has_ipv6
+
+
+HAS_IPV6 = _has_ipv6('::1')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/queue.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/queue.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3d379a19997b0c76c820a82e10b8fd36db9bea4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/urllib3/util/queue.py
@@ -0,0 +1,21 @@
+import collections
+from ..packages import six
+from ..packages.six.moves import queue
+
+if six.PY2:
+    # Queue is imported for side effects on MS Windows. See issue #229.
+    import Queue as _unused_module_Queue  # noqa: F401
+
+
+class LifoQueue(queue.Queue):
+    def _init(self, _):
+        self.queue = collections.deque()
+
+    def _qsize(self, len=len):
+        return len(self.queue)
+
+    def _put(self, item):
+        self.queue.append(item)
+
+    def _get(self):
+        return self.queue.pop()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d21d697c887bed1f8ab7f36d10185e986d9f1e54
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/__init__.py
@@ -0,0 +1,342 @@
+# coding: utf-8
+"""
+
+    webencodings
+    ~~~~~~~~~~~~
+
+    This is a Python implementation of the `WHATWG Encoding standard
+    <http://encoding.spec.whatwg.org/>`. See README for details.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+import codecs
+
+from .labels import LABELS
+
+
+VERSION = '0.5.1'
+
+
+# Some names in Encoding are not valid Python aliases. Remap these.
+PYTHON_NAMES = {
+    'iso-8859-8-i': 'iso-8859-8',
+    'x-mac-cyrillic': 'mac-cyrillic',
+    'macintosh': 'mac-roman',
+    'windows-874': 'cp874'}
+
+CACHE = {}
+
+
+def ascii_lower(string):
+    r"""Transform (only) ASCII letters to lower case: A-Z is mapped to a-z.
+
+    :param string: An Unicode string.
+    :returns: A new Unicode string.
+
+    This is used for `ASCII case-insensitive
+    <http://encoding.spec.whatwg.org/#ascii-case-insensitive>`_
+    matching of encoding labels.
+    The same matching is also used, among other things,
+    for `CSS keywords <http://dev.w3.org/csswg/css-values/#keywords>`_.
+
+    This is different from the :meth:`~py:str.lower` method of Unicode strings
+    which also affect non-ASCII characters,
+    sometimes mapping them into the ASCII range:
+
+        >>> keyword = u'Bac\N{KELVIN SIGN}ground'
+        >>> assert keyword.lower() == u'background'
+        >>> assert ascii_lower(keyword) != keyword.lower()
+        >>> assert ascii_lower(keyword) == u'bac\N{KELVIN SIGN}ground'
+
+    """
+    # This turns out to be faster than unicode.translate()
+    return string.encode('utf8').lower().decode('utf8')
+
+
+def lookup(label):
+    """
+    Look for an encoding by its label.
+    This is the spec’s `get an encoding
+    <http://encoding.spec.whatwg.org/#concept-encoding-get>`_ algorithm.
+    Supported labels are listed there.
+
+    :param label: A string.
+    :returns:
+        An :class:`Encoding` object, or :obj:`None` for an unknown label.
+
+    """
+    # Only strip ASCII whitespace: U+0009, U+000A, U+000C, U+000D, and U+0020.
+    label = ascii_lower(label.strip('\t\n\f\r '))
+    name = LABELS.get(label)
+    if name is None:
+        return None
+    encoding = CACHE.get(name)
+    if encoding is None:
+        if name == 'x-user-defined':
+            from .x_user_defined import codec_info
+        else:
+            python_name = PYTHON_NAMES.get(name, name)
+            # Any python_name value that gets to here should be valid.
+            codec_info = codecs.lookup(python_name)
+        encoding = Encoding(name, codec_info)
+        CACHE[name] = encoding
+    return encoding
+
+
+def _get_encoding(encoding_or_label):
+    """
+    Accept either an encoding object or label.
+
+    :param encoding: An :class:`Encoding` object or a label string.
+    :returns: An :class:`Encoding` object.
+    :raises: :exc:`~exceptions.LookupError` for an unknown label.
+
+    """
+    if hasattr(encoding_or_label, 'codec_info'):
+        return encoding_or_label
+
+    encoding = lookup(encoding_or_label)
+    if encoding is None:
+        raise LookupError('Unknown encoding label: %r' % encoding_or_label)
+    return encoding
+
+
+class Encoding(object):
+    """Reresents a character encoding such as UTF-8,
+    that can be used for decoding or encoding.
+
+    .. attribute:: name
+
+        Canonical name of the encoding
+
+    .. attribute:: codec_info
+
+        The actual implementation of the encoding,
+        a stdlib :class:`~codecs.CodecInfo` object.
+        See :func:`codecs.register`.
+
+    """
+    def __init__(self, name, codec_info):
+        self.name = name
+        self.codec_info = codec_info
+
+    def __repr__(self):
+        return '<Encoding %s>' % self.name
+
+
+#: The UTF-8 encoding. Should be used for new content and formats.
+UTF8 = lookup('utf-8')
+
+_UTF16LE = lookup('utf-16le')
+_UTF16BE = lookup('utf-16be')
+
+
+def decode(input, fallback_encoding, errors='replace'):
+    """
+    Decode a single string.
+
+    :param input: A byte string
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :return:
+        A ``(output, encoding)`` tuple of an Unicode string
+        and an :obj:`Encoding`.
+
+    """
+    # Fail early if `encoding` is an invalid label.
+    fallback_encoding = _get_encoding(fallback_encoding)
+    bom_encoding, input = _detect_bom(input)
+    encoding = bom_encoding or fallback_encoding
+    return encoding.codec_info.decode(input, errors)[0], encoding
+
+
+def _detect_bom(input):
+    """Return (bom_encoding, input), with any BOM removed from the input."""
+    if input.startswith(b'\xFF\xFE'):
+        return _UTF16LE, input[2:]
+    if input.startswith(b'\xFE\xFF'):
+        return _UTF16BE, input[2:]
+    if input.startswith(b'\xEF\xBB\xBF'):
+        return UTF8, input[3:]
+    return None, input
+
+
+def encode(input, encoding=UTF8, errors='strict'):
+    """
+    Encode a single string.
+
+    :param input: An Unicode string.
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :return: A byte string.
+
+    """
+    return _get_encoding(encoding).codec_info.encode(input, errors)[0]
+
+
+def iter_decode(input, fallback_encoding, errors='replace'):
+    """
+    "Pull"-based decoder.
+
+    :param input:
+        An iterable of byte strings.
+
+        The input is first consumed just enough to determine the encoding
+        based on the precense of a BOM,
+        then consumed on demand when the return value is.
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :returns:
+        An ``(output, encoding)`` tuple.
+        :obj:`output` is an iterable of Unicode strings,
+        :obj:`encoding` is the :obj:`Encoding` that is being used.
+
+    """
+
+    decoder = IncrementalDecoder(fallback_encoding, errors)
+    generator = _iter_decode_generator(input, decoder)
+    encoding = next(generator)
+    return generator, encoding
+
+
+def _iter_decode_generator(input, decoder):
+    """Return a generator that first yields the :obj:`Encoding`,
+    then yields output chukns as Unicode strings.
+
+    """
+    decode = decoder.decode
+    input = iter(input)
+    for chunck in input:
+        output = decode(chunck)
+        if output:
+            assert decoder.encoding is not None
+            yield decoder.encoding
+            yield output
+            break
+    else:
+        # Input exhausted without determining the encoding
+        output = decode(b'', final=True)
+        assert decoder.encoding is not None
+        yield decoder.encoding
+        if output:
+            yield output
+        return
+
+    for chunck in input:
+        output = decode(chunck)
+        if output:
+            yield output
+    output = decode(b'', final=True)
+    if output:
+        yield output
+
+
+def iter_encode(input, encoding=UTF8, errors='strict'):
+    """
+    “Pull”-based encoder.
+
+    :param input: An iterable of Unicode strings.
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+    :returns: An iterable of byte strings.
+
+    """
+    # Fail early if `encoding` is an invalid label.
+    encode = IncrementalEncoder(encoding, errors).encode
+    return _iter_encode_generator(input, encode)
+
+
+def _iter_encode_generator(input, encode):
+    for chunck in input:
+        output = encode(chunck)
+        if output:
+            yield output
+    output = encode('', final=True)
+    if output:
+        yield output
+
+
+class IncrementalDecoder(object):
+    """
+    “Push”-based decoder.
+
+    :param fallback_encoding:
+        An :class:`Encoding` object or a label string.
+        The encoding to use if :obj:`input` does note have a BOM.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+
+    """
+    def __init__(self, fallback_encoding, errors='replace'):
+        # Fail early if `encoding` is an invalid label.
+        self._fallback_encoding = _get_encoding(fallback_encoding)
+        self._errors = errors
+        self._buffer = b''
+        self._decoder = None
+        #: The actual :class:`Encoding` that is being used,
+        #: or :obj:`None` if that is not determined yet.
+        #: (Ie. if there is not enough input yet to determine
+        #: if there is a BOM.)
+        self.encoding = None  # Not known yet.
+
+    def decode(self, input, final=False):
+        """Decode one chunk of the input.
+
+        :param input: A byte string.
+        :param final:
+            Indicate that no more input is available.
+            Must be :obj:`True` if this is the last call.
+        :returns: An Unicode string.
+
+        """
+        decoder = self._decoder
+        if decoder is not None:
+            return decoder(input, final)
+
+        input = self._buffer + input
+        encoding, input = _detect_bom(input)
+        if encoding is None:
+            if len(input) < 3 and not final:  # Not enough data yet.
+                self._buffer = input
+                return ''
+            else:  # No BOM
+                encoding = self._fallback_encoding
+        decoder = encoding.codec_info.incrementaldecoder(self._errors).decode
+        self._decoder = decoder
+        self.encoding = encoding
+        return decoder(input, final)
+
+
+class IncrementalEncoder(object):
+    """
+    “Push”-based encoder.
+
+    :param encoding: An :class:`Encoding` object or a label string.
+    :param errors: Type of error handling. See :func:`codecs.register`.
+    :raises: :exc:`~exceptions.LookupError` for an unknown encoding label.
+
+    .. method:: encode(input, final=False)
+
+        :param input: An Unicode string.
+        :param final:
+            Indicate that no more input is available.
+            Must be :obj:`True` if this is the last call.
+        :returns: A byte string.
+
+    """
+    def __init__(self, encoding=UTF8, errors='strict'):
+        encoding = _get_encoding(encoding)
+        self.encode = encoding.codec_info.incrementalencoder(errors).encode
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/labels.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/labels.py
new file mode 100644
index 0000000000000000000000000000000000000000..29cbf91ef79b89971e51db9ddfc3720d8b4db82a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/labels.py
@@ -0,0 +1,231 @@
+"""
+
+    webencodings.labels
+    ~~~~~~~~~~~~~~~~~~~
+
+    Map encoding labels to their name.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+# XXX Do not edit!
+# This file is automatically generated by mklabels.py
+
+LABELS = {
+    'unicode-1-1-utf-8':   'utf-8',
+    'utf-8':               'utf-8',
+    'utf8':                'utf-8',
+    '866':                 'ibm866',
+    'cp866':               'ibm866',
+    'csibm866':            'ibm866',
+    'ibm866':              'ibm866',
+    'csisolatin2':         'iso-8859-2',
+    'iso-8859-2':          'iso-8859-2',
+    'iso-ir-101':          'iso-8859-2',
+    'iso8859-2':           'iso-8859-2',
+    'iso88592':            'iso-8859-2',
+    'iso_8859-2':          'iso-8859-2',
+    'iso_8859-2:1987':     'iso-8859-2',
+    'l2':                  'iso-8859-2',
+    'latin2':              'iso-8859-2',
+    'csisolatin3':         'iso-8859-3',
+    'iso-8859-3':          'iso-8859-3',
+    'iso-ir-109':          'iso-8859-3',
+    'iso8859-3':           'iso-8859-3',
+    'iso88593':            'iso-8859-3',
+    'iso_8859-3':          'iso-8859-3',
+    'iso_8859-3:1988':     'iso-8859-3',
+    'l3':                  'iso-8859-3',
+    'latin3':              'iso-8859-3',
+    'csisolatin4':         'iso-8859-4',
+    'iso-8859-4':          'iso-8859-4',
+    'iso-ir-110':          'iso-8859-4',
+    'iso8859-4':           'iso-8859-4',
+    'iso88594':            'iso-8859-4',
+    'iso_8859-4':          'iso-8859-4',
+    'iso_8859-4:1988':     'iso-8859-4',
+    'l4':                  'iso-8859-4',
+    'latin4':              'iso-8859-4',
+    'csisolatincyrillic':  'iso-8859-5',
+    'cyrillic':            'iso-8859-5',
+    'iso-8859-5':          'iso-8859-5',
+    'iso-ir-144':          'iso-8859-5',
+    'iso8859-5':           'iso-8859-5',
+    'iso88595':            'iso-8859-5',
+    'iso_8859-5':          'iso-8859-5',
+    'iso_8859-5:1988':     'iso-8859-5',
+    'arabic':              'iso-8859-6',
+    'asmo-708':            'iso-8859-6',
+    'csiso88596e':         'iso-8859-6',
+    'csiso88596i':         'iso-8859-6',
+    'csisolatinarabic':    'iso-8859-6',
+    'ecma-114':            'iso-8859-6',
+    'iso-8859-6':          'iso-8859-6',
+    'iso-8859-6-e':        'iso-8859-6',
+    'iso-8859-6-i':        'iso-8859-6',
+    'iso-ir-127':          'iso-8859-6',
+    'iso8859-6':           'iso-8859-6',
+    'iso88596':            'iso-8859-6',
+    'iso_8859-6':          'iso-8859-6',
+    'iso_8859-6:1987':     'iso-8859-6',
+    'csisolatingreek':     'iso-8859-7',
+    'ecma-118':            'iso-8859-7',
+    'elot_928':            'iso-8859-7',
+    'greek':               'iso-8859-7',
+    'greek8':              'iso-8859-7',
+    'iso-8859-7':          'iso-8859-7',
+    'iso-ir-126':          'iso-8859-7',
+    'iso8859-7':           'iso-8859-7',
+    'iso88597':            'iso-8859-7',
+    'iso_8859-7':          'iso-8859-7',
+    'iso_8859-7:1987':     'iso-8859-7',
+    'sun_eu_greek':        'iso-8859-7',
+    'csiso88598e':         'iso-8859-8',
+    'csisolatinhebrew':    'iso-8859-8',
+    'hebrew':              'iso-8859-8',
+    'iso-8859-8':          'iso-8859-8',
+    'iso-8859-8-e':        'iso-8859-8',
+    'iso-ir-138':          'iso-8859-8',
+    'iso8859-8':           'iso-8859-8',
+    'iso88598':            'iso-8859-8',
+    'iso_8859-8':          'iso-8859-8',
+    'iso_8859-8:1988':     'iso-8859-8',
+    'visual':              'iso-8859-8',
+    'csiso88598i':         'iso-8859-8-i',
+    'iso-8859-8-i':        'iso-8859-8-i',
+    'logical':             'iso-8859-8-i',
+    'csisolatin6':         'iso-8859-10',
+    'iso-8859-10':         'iso-8859-10',
+    'iso-ir-157':          'iso-8859-10',
+    'iso8859-10':          'iso-8859-10',
+    'iso885910':           'iso-8859-10',
+    'l6':                  'iso-8859-10',
+    'latin6':              'iso-8859-10',
+    'iso-8859-13':         'iso-8859-13',
+    'iso8859-13':          'iso-8859-13',
+    'iso885913':           'iso-8859-13',
+    'iso-8859-14':         'iso-8859-14',
+    'iso8859-14':          'iso-8859-14',
+    'iso885914':           'iso-8859-14',
+    'csisolatin9':         'iso-8859-15',
+    'iso-8859-15':         'iso-8859-15',
+    'iso8859-15':          'iso-8859-15',
+    'iso885915':           'iso-8859-15',
+    'iso_8859-15':         'iso-8859-15',
+    'l9':                  'iso-8859-15',
+    'iso-8859-16':         'iso-8859-16',
+    'cskoi8r':             'koi8-r',
+    'koi':                 'koi8-r',
+    'koi8':                'koi8-r',
+    'koi8-r':              'koi8-r',
+    'koi8_r':              'koi8-r',
+    'koi8-u':              'koi8-u',
+    'csmacintosh':         'macintosh',
+    'mac':                 'macintosh',
+    'macintosh':           'macintosh',
+    'x-mac-roman':         'macintosh',
+    'dos-874':             'windows-874',
+    'iso-8859-11':         'windows-874',
+    'iso8859-11':          'windows-874',
+    'iso885911':           'windows-874',
+    'tis-620':             'windows-874',
+    'windows-874':         'windows-874',
+    'cp1250':              'windows-1250',
+    'windows-1250':        'windows-1250',
+    'x-cp1250':            'windows-1250',
+    'cp1251':              'windows-1251',
+    'windows-1251':        'windows-1251',
+    'x-cp1251':            'windows-1251',
+    'ansi_x3.4-1968':      'windows-1252',
+    'ascii':               'windows-1252',
+    'cp1252':              'windows-1252',
+    'cp819':               'windows-1252',
+    'csisolatin1':         'windows-1252',
+    'ibm819':              'windows-1252',
+    'iso-8859-1':          'windows-1252',
+    'iso-ir-100':          'windows-1252',
+    'iso8859-1':           'windows-1252',
+    'iso88591':            'windows-1252',
+    'iso_8859-1':          'windows-1252',
+    'iso_8859-1:1987':     'windows-1252',
+    'l1':                  'windows-1252',
+    'latin1':              'windows-1252',
+    'us-ascii':            'windows-1252',
+    'windows-1252':        'windows-1252',
+    'x-cp1252':            'windows-1252',
+    'cp1253':              'windows-1253',
+    'windows-1253':        'windows-1253',
+    'x-cp1253':            'windows-1253',
+    'cp1254':              'windows-1254',
+    'csisolatin5':         'windows-1254',
+    'iso-8859-9':          'windows-1254',
+    'iso-ir-148':          'windows-1254',
+    'iso8859-9':           'windows-1254',
+    'iso88599':            'windows-1254',
+    'iso_8859-9':          'windows-1254',
+    'iso_8859-9:1989':     'windows-1254',
+    'l5':                  'windows-1254',
+    'latin5':              'windows-1254',
+    'windows-1254':        'windows-1254',
+    'x-cp1254':            'windows-1254',
+    'cp1255':              'windows-1255',
+    'windows-1255':        'windows-1255',
+    'x-cp1255':            'windows-1255',
+    'cp1256':              'windows-1256',
+    'windows-1256':        'windows-1256',
+    'x-cp1256':            'windows-1256',
+    'cp1257':              'windows-1257',
+    'windows-1257':        'windows-1257',
+    'x-cp1257':            'windows-1257',
+    'cp1258':              'windows-1258',
+    'windows-1258':        'windows-1258',
+    'x-cp1258':            'windows-1258',
+    'x-mac-cyrillic':      'x-mac-cyrillic',
+    'x-mac-ukrainian':     'x-mac-cyrillic',
+    'chinese':             'gbk',
+    'csgb2312':            'gbk',
+    'csiso58gb231280':     'gbk',
+    'gb2312':              'gbk',
+    'gb_2312':             'gbk',
+    'gb_2312-80':          'gbk',
+    'gbk':                 'gbk',
+    'iso-ir-58':           'gbk',
+    'x-gbk':               'gbk',
+    'gb18030':             'gb18030',
+    'hz-gb-2312':          'hz-gb-2312',
+    'big5':                'big5',
+    'big5-hkscs':          'big5',
+    'cn-big5':             'big5',
+    'csbig5':              'big5',
+    'x-x-big5':            'big5',
+    'cseucpkdfmtjapanese': 'euc-jp',
+    'euc-jp':              'euc-jp',
+    'x-euc-jp':            'euc-jp',
+    'csiso2022jp':         'iso-2022-jp',
+    'iso-2022-jp':         'iso-2022-jp',
+    'csshiftjis':          'shift_jis',
+    'ms_kanji':            'shift_jis',
+    'shift-jis':           'shift_jis',
+    'shift_jis':           'shift_jis',
+    'sjis':                'shift_jis',
+    'windows-31j':         'shift_jis',
+    'x-sjis':              'shift_jis',
+    'cseuckr':             'euc-kr',
+    'csksc56011987':       'euc-kr',
+    'euc-kr':              'euc-kr',
+    'iso-ir-149':          'euc-kr',
+    'korean':              'euc-kr',
+    'ks_c_5601-1987':      'euc-kr',
+    'ks_c_5601-1989':      'euc-kr',
+    'ksc5601':             'euc-kr',
+    'ksc_5601':            'euc-kr',
+    'windows-949':         'euc-kr',
+    'csiso2022kr':         'iso-2022-kr',
+    'iso-2022-kr':         'iso-2022-kr',
+    'utf-16be':            'utf-16be',
+    'utf-16':              'utf-16le',
+    'utf-16le':            'utf-16le',
+    'x-user-defined':      'x-user-defined',
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/mklabels.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/mklabels.py
new file mode 100644
index 0000000000000000000000000000000000000000..295dc928ba71fc00caa52708ac70097abe6dc3e4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/mklabels.py
@@ -0,0 +1,59 @@
+"""
+
+    webencodings.mklabels
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Regenarate the webencodings.labels module.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+import json
+try:
+    from urllib import urlopen
+except ImportError:
+    from urllib.request import urlopen
+
+
+def assert_lower(string):
+    assert string == string.lower()
+    return string
+
+
+def generate(url):
+    parts = ['''\
+"""
+
+    webencodings.labels
+    ~~~~~~~~~~~~~~~~~~~
+
+    Map encoding labels to their name.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+# XXX Do not edit!
+# This file is automatically generated by mklabels.py
+
+LABELS = {
+''']
+    labels = [
+        (repr(assert_lower(label)).lstrip('u'),
+         repr(encoding['name']).lstrip('u'))
+        for category in json.loads(urlopen(url).read().decode('ascii'))
+        for encoding in category['encodings']
+        for label in encoding['labels']]
+    max_len = max(len(label) for label, name in labels)
+    parts.extend(
+        '    %s:%s %s,\n' % (label, ' ' * (max_len - len(label)), name)
+        for label, name in labels)
+    parts.append('}')
+    return ''.join(parts)
+
+
+if __name__ == '__main__':
+    print(generate('http://encoding.spec.whatwg.org/encodings.json'))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/tests.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..e12c10d033026f09cf97b81d29555e12aae8c762
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/tests.py
@@ -0,0 +1,153 @@
+# coding: utf-8
+"""
+
+    webencodings.tests
+    ~~~~~~~~~~~~~~~~~~
+
+    A basic test suite for Encoding.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+from . import (lookup, LABELS, decode, encode, iter_decode, iter_encode,
+               IncrementalDecoder, IncrementalEncoder, UTF8)
+
+
+def assert_raises(exception, function, *args, **kwargs):
+    try:
+        function(*args, **kwargs)
+    except exception:
+        return
+    else:  # pragma: no cover
+        raise AssertionError('Did not raise %s.' % exception)
+
+
+def test_labels():
+    assert lookup('utf-8').name == 'utf-8'
+    assert lookup('Utf-8').name == 'utf-8'
+    assert lookup('UTF-8').name == 'utf-8'
+    assert lookup('utf8').name == 'utf-8'
+    assert lookup('utf8').name == 'utf-8'
+    assert lookup('utf8 ').name == 'utf-8'
+    assert lookup(' \r\nutf8\t').name == 'utf-8'
+    assert lookup('u8') is None  # Python label.
+    assert lookup('utf-8 ') is None  # Non-ASCII white space.
+
+    assert lookup('US-ASCII').name == 'windows-1252'
+    assert lookup('iso-8859-1').name == 'windows-1252'
+    assert lookup('latin1').name == 'windows-1252'
+    assert lookup('LATIN1').name == 'windows-1252'
+    assert lookup('latin-1') is None
+    assert lookup('LATİN1') is None  # ASCII-only case insensitivity.
+
+
+def test_all_labels():
+    for label in LABELS:
+        assert decode(b'', label) == ('', lookup(label))
+        assert encode('', label) == b''
+        for repeat in [0, 1, 12]:
+            output, _ = iter_decode([b''] * repeat, label)
+            assert list(output) == []
+            assert list(iter_encode([''] * repeat, label)) == []
+        decoder = IncrementalDecoder(label)
+        assert decoder.decode(b'') == ''
+        assert decoder.decode(b'', final=True) == ''
+        encoder = IncrementalEncoder(label)
+        assert encoder.encode('') == b''
+        assert encoder.encode('', final=True) == b''
+    # All encoding names are valid labels too:
+    for name in set(LABELS.values()):
+        assert lookup(name).name == name
+
+
+def test_invalid_label():
+    assert_raises(LookupError, decode, b'\xEF\xBB\xBF\xc3\xa9', 'invalid')
+    assert_raises(LookupError, encode, 'é', 'invalid')
+    assert_raises(LookupError, iter_decode, [], 'invalid')
+    assert_raises(LookupError, iter_encode, [], 'invalid')
+    assert_raises(LookupError, IncrementalDecoder, 'invalid')
+    assert_raises(LookupError, IncrementalEncoder, 'invalid')
+
+
+def test_decode():
+    assert decode(b'\x80', 'latin1') == ('€', lookup('latin1'))
+    assert decode(b'\x80', lookup('latin1')) == ('€', lookup('latin1'))
+    assert decode(b'\xc3\xa9', 'utf8') == ('é', lookup('utf8'))
+    assert decode(b'\xc3\xa9', UTF8) == ('é', lookup('utf8'))
+    assert decode(b'\xc3\xa9', 'ascii') == ('é', lookup('ascii'))
+    assert decode(b'\xEF\xBB\xBF\xc3\xa9', 'ascii') == ('é', lookup('utf8'))  # UTF-8 with BOM
+
+    assert decode(b'\xFE\xFF\x00\xe9', 'ascii') == ('é', lookup('utf-16be'))  # UTF-16-BE with BOM
+    assert decode(b'\xFF\xFE\xe9\x00', 'ascii') == ('é', lookup('utf-16le'))  # UTF-16-LE with BOM
+    assert decode(b'\xFE\xFF\xe9\x00', 'ascii') == ('\ue900', lookup('utf-16be'))
+    assert decode(b'\xFF\xFE\x00\xe9', 'ascii') == ('\ue900', lookup('utf-16le'))
+
+    assert decode(b'\x00\xe9', 'UTF-16BE') == ('é', lookup('utf-16be'))
+    assert decode(b'\xe9\x00', 'UTF-16LE') == ('é', lookup('utf-16le'))
+    assert decode(b'\xe9\x00', 'UTF-16') == ('é', lookup('utf-16le'))
+
+    assert decode(b'\xe9\x00', 'UTF-16BE') == ('\ue900', lookup('utf-16be'))
+    assert decode(b'\x00\xe9', 'UTF-16LE') == ('\ue900', lookup('utf-16le'))
+    assert decode(b'\x00\xe9', 'UTF-16') == ('\ue900', lookup('utf-16le'))
+
+
+def test_encode():
+    assert encode('é', 'latin1') == b'\xe9'
+    assert encode('é', 'utf8') == b'\xc3\xa9'
+    assert encode('é', 'utf8') == b'\xc3\xa9'
+    assert encode('é', 'utf-16') == b'\xe9\x00'
+    assert encode('é', 'utf-16le') == b'\xe9\x00'
+    assert encode('é', 'utf-16be') == b'\x00\xe9'
+
+
+def test_iter_decode():
+    def iter_decode_to_string(input, fallback_encoding):
+        output, _encoding = iter_decode(input, fallback_encoding)
+        return ''.join(output)
+    assert iter_decode_to_string([], 'latin1') == ''
+    assert iter_decode_to_string([b''], 'latin1') == ''
+    assert iter_decode_to_string([b'\xe9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'hello'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'he', b'llo'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'hell', b'o'], 'latin1') == 'hello'
+    assert iter_decode_to_string([b'\xc3\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xEF\xBB\xBF\xc3\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'\xEF\xBB\xBF', b'\xc3', b'\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'\xEF\xBB\xBF', b'a', b'\xc3'], 'latin1') == 'a\uFFFD'
+    assert iter_decode_to_string([
+        b'', b'\xEF', b'', b'', b'\xBB\xBF\xc3', b'\xa9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xEF\xBB\xBF'], 'latin1') == ''
+    assert iter_decode_to_string([b'\xEF\xBB'], 'latin1') == 'ï»'
+    assert iter_decode_to_string([b'\xFE\xFF\x00\xe9'], 'latin1') == 'é'
+    assert iter_decode_to_string([b'\xFF\xFE\xe9\x00'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'', b'\xFF', b'', b'', b'\xFE\xe9', b'\x00'], 'latin1') == 'é'
+    assert iter_decode_to_string([
+        b'', b'h\xe9', b'llo'], 'x-user-defined') == 'h\uF7E9llo'
+
+
+def test_iter_encode():
+    assert b''.join(iter_encode([], 'latin1')) == b''
+    assert b''.join(iter_encode([''], 'latin1')) == b''
+    assert b''.join(iter_encode(['é'], 'latin1')) == b'\xe9'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'latin1')) == b'\xe9'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16')) == b'\xe9\x00'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16le')) == b'\xe9\x00'
+    assert b''.join(iter_encode(['', 'é', '', ''], 'utf-16be')) == b'\x00\xe9'
+    assert b''.join(iter_encode([
+        '', 'h\uF7E9', '', 'llo'], 'x-user-defined')) == b'h\xe9llo'
+
+
+def test_x_user_defined():
+    encoded = b'2,\x0c\x0b\x1aO\xd9#\xcb\x0f\xc9\xbbt\xcf\xa8\xca'
+    decoded = '2,\x0c\x0b\x1aO\uf7d9#\uf7cb\x0f\uf7c9\uf7bbt\uf7cf\uf7a8\uf7ca'
+    encoded = b'aa'
+    decoded = 'aa'
+    assert decode(encoded, 'x-user-defined') == (decoded, lookup('x-user-defined'))
+    assert encode(decoded, 'x-user-defined') == encoded
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/x_user_defined.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/x_user_defined.py
new file mode 100644
index 0000000000000000000000000000000000000000..d16e326024c05a59548619e13258acad781e0a6d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/webencodings/x_user_defined.py
@@ -0,0 +1,325 @@
+# coding: utf-8
+"""
+
+    webencodings.x_user_defined
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    An implementation of the x-user-defined encoding.
+
+    :copyright: Copyright 2012 by Simon Sapin
+    :license: BSD, see LICENSE for details.
+
+"""
+
+from __future__ import unicode_literals
+
+import codecs
+
+
+### Codec APIs
+
+class Codec(codecs.Codec):
+
+    def encode(self, input, errors='strict'):
+        return codecs.charmap_encode(input, errors, encoding_table)
+
+    def decode(self, input, errors='strict'):
+        return codecs.charmap_decode(input, errors, decoding_table)
+
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input, final=False):
+        return codecs.charmap_encode(input, self.errors, encoding_table)[0]
+
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input, final=False):
+        return codecs.charmap_decode(input, self.errors, decoding_table)[0]
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+### encodings module API
+
+codec_info = codecs.CodecInfo(
+    name='x-user-defined',
+    encode=Codec().encode,
+    decode=Codec().decode,
+    incrementalencoder=IncrementalEncoder,
+    incrementaldecoder=IncrementalDecoder,
+    streamreader=StreamReader,
+    streamwriter=StreamWriter,
+)
+
+
+### Decoding Table
+
+# Python 3:
+# for c in range(256): print('    %r' % chr(c if c < 128 else c + 0xF700))
+decoding_table = (
+    '\x00'
+    '\x01'
+    '\x02'
+    '\x03'
+    '\x04'
+    '\x05'
+    '\x06'
+    '\x07'
+    '\x08'
+    '\t'
+    '\n'
+    '\x0b'
+    '\x0c'
+    '\r'
+    '\x0e'
+    '\x0f'
+    '\x10'
+    '\x11'
+    '\x12'
+    '\x13'
+    '\x14'
+    '\x15'
+    '\x16'
+    '\x17'
+    '\x18'
+    '\x19'
+    '\x1a'
+    '\x1b'
+    '\x1c'
+    '\x1d'
+    '\x1e'
+    '\x1f'
+    ' '
+    '!'
+    '"'
+    '#'
+    '$'
+    '%'
+    '&'
+    "'"
+    '('
+    ')'
+    '*'
+    '+'
+    ','
+    '-'
+    '.'
+    '/'
+    '0'
+    '1'
+    '2'
+    '3'
+    '4'
+    '5'
+    '6'
+    '7'
+    '8'
+    '9'
+    ':'
+    ';'
+    '<'
+    '='
+    '>'
+    '?'
+    '@'
+    'A'
+    'B'
+    'C'
+    'D'
+    'E'
+    'F'
+    'G'
+    'H'
+    'I'
+    'J'
+    'K'
+    'L'
+    'M'
+    'N'
+    'O'
+    'P'
+    'Q'
+    'R'
+    'S'
+    'T'
+    'U'
+    'V'
+    'W'
+    'X'
+    'Y'
+    'Z'
+    '['
+    '\\'
+    ']'
+    '^'
+    '_'
+    '`'
+    'a'
+    'b'
+    'c'
+    'd'
+    'e'
+    'f'
+    'g'
+    'h'
+    'i'
+    'j'
+    'k'
+    'l'
+    'm'
+    'n'
+    'o'
+    'p'
+    'q'
+    'r'
+    's'
+    't'
+    'u'
+    'v'
+    'w'
+    'x'
+    'y'
+    'z'
+    '{'
+    '|'
+    '}'
+    '~'
+    '\x7f'
+    '\uf780'
+    '\uf781'
+    '\uf782'
+    '\uf783'
+    '\uf784'
+    '\uf785'
+    '\uf786'
+    '\uf787'
+    '\uf788'
+    '\uf789'
+    '\uf78a'
+    '\uf78b'
+    '\uf78c'
+    '\uf78d'
+    '\uf78e'
+    '\uf78f'
+    '\uf790'
+    '\uf791'
+    '\uf792'
+    '\uf793'
+    '\uf794'
+    '\uf795'
+    '\uf796'
+    '\uf797'
+    '\uf798'
+    '\uf799'
+    '\uf79a'
+    '\uf79b'
+    '\uf79c'
+    '\uf79d'
+    '\uf79e'
+    '\uf79f'
+    '\uf7a0'
+    '\uf7a1'
+    '\uf7a2'
+    '\uf7a3'
+    '\uf7a4'
+    '\uf7a5'
+    '\uf7a6'
+    '\uf7a7'
+    '\uf7a8'
+    '\uf7a9'
+    '\uf7aa'
+    '\uf7ab'
+    '\uf7ac'
+    '\uf7ad'
+    '\uf7ae'
+    '\uf7af'
+    '\uf7b0'
+    '\uf7b1'
+    '\uf7b2'
+    '\uf7b3'
+    '\uf7b4'
+    '\uf7b5'
+    '\uf7b6'
+    '\uf7b7'
+    '\uf7b8'
+    '\uf7b9'
+    '\uf7ba'
+    '\uf7bb'
+    '\uf7bc'
+    '\uf7bd'
+    '\uf7be'
+    '\uf7bf'
+    '\uf7c0'
+    '\uf7c1'
+    '\uf7c2'
+    '\uf7c3'
+    '\uf7c4'
+    '\uf7c5'
+    '\uf7c6'
+    '\uf7c7'
+    '\uf7c8'
+    '\uf7c9'
+    '\uf7ca'
+    '\uf7cb'
+    '\uf7cc'
+    '\uf7cd'
+    '\uf7ce'
+    '\uf7cf'
+    '\uf7d0'
+    '\uf7d1'
+    '\uf7d2'
+    '\uf7d3'
+    '\uf7d4'
+    '\uf7d5'
+    '\uf7d6'
+    '\uf7d7'
+    '\uf7d8'
+    '\uf7d9'
+    '\uf7da'
+    '\uf7db'
+    '\uf7dc'
+    '\uf7dd'
+    '\uf7de'
+    '\uf7df'
+    '\uf7e0'
+    '\uf7e1'
+    '\uf7e2'
+    '\uf7e3'
+    '\uf7e4'
+    '\uf7e5'
+    '\uf7e6'
+    '\uf7e7'
+    '\uf7e8'
+    '\uf7e9'
+    '\uf7ea'
+    '\uf7eb'
+    '\uf7ec'
+    '\uf7ed'
+    '\uf7ee'
+    '\uf7ef'
+    '\uf7f0'
+    '\uf7f1'
+    '\uf7f2'
+    '\uf7f3'
+    '\uf7f4'
+    '\uf7f5'
+    '\uf7f6'
+    '\uf7f7'
+    '\uf7f8'
+    '\uf7f9'
+    '\uf7fa'
+    '\uf7fb'
+    '\uf7fc'
+    '\uf7fd'
+    '\uf7fe'
+    '\uf7ff'
+)
+
+### Encoding table
+encoding_table = codecs.charmap_build(decoding_table)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/appdirs.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/appdirs.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae67001af8b661373edeee2eb327b9f63e630d62
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/appdirs.py
@@ -0,0 +1,608 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See <http://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version_info__ = (1, 4, 3)
+__version__ = '.'.join(map(str, __version_info__))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               same as user_data_dir
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system in ["win32", "darwin"]:
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    if PY3:
+      import winreg as _winreg
+    else:
+      import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/_compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..210bb80b7e7b64cb79f7e7cdf3e42819fe3471fe
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/_compat.py
@@ -0,0 +1,30 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+    string_types = str,
+else:
+    string_types = basestring,
+
+
+def with_metaclass(meta, *bases):
+    """
+    Create a base class with a metaclass.
+    """
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/markers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/markers.py
new file mode 100644
index 0000000000000000000000000000000000000000..892e578edd4b992cc2996c31d9deb13af73d62c0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/markers.py
@@ -0,0 +1,301 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import operator
+import os
+import platform
+import sys
+
+from pkg_resources.extern.pyparsing import ParseException, ParseResults, stringStart, stringEnd
+from pkg_resources.extern.pyparsing import ZeroOrMore, Group, Forward, QuotedString
+from pkg_resources.extern.pyparsing import Literal as L  # noqa
+
+from ._compat import string_types
+from .specifiers import Specifier, InvalidSpecifier
+
+
+__all__ = [
+    "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName",
+    "Marker", "default_environment",
+]
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node(object):
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
+
+    def serialize(self):
+        raise NotImplementedError
+
+
+class Variable(Node):
+
+    def serialize(self):
+        return str(self)
+
+
+class Value(Node):
+
+    def serialize(self):
+        return '"{0}"'.format(self)
+
+
+class Op(Node):
+
+    def serialize(self):
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version") |
+    L("platform_python_implementation") |
+    L("implementation_name") |
+    L("python_full_version") |
+    L("platform_release") |
+    L("platform_version") |
+    L("platform_machine") |
+    L("platform_system") |
+    L("python_version") |
+    L("sys_platform") |
+    L("os_name") |
+    L("os.name") |  # PEP-345
+    L("sys.platform") |  # PEP-345
+    L("platform.version") |  # PEP-345
+    L("platform.machine") |  # PEP-345
+    L("platform.python_implementation") |  # PEP-345
+    L("python_implementation") |  # undocumented setuptools legacy
+    L("extra")
+)
+ALIASES = {
+    'os.name': 'os_name',
+    'sys.platform': 'sys_platform',
+    'platform.version': 'platform_version',
+    'platform.machine': 'platform_machine',
+    'platform.python_implementation': 'platform_python_implementation',
+    'python_implementation': 'platform_python_implementation'
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") |
+    L("==") |
+    L(">=") |
+    L("<=") |
+    L("!=") |
+    L("~=") |
+    L(">") |
+    L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results):
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(marker, first=True):
+    assert isinstance(marker, (list, tuple, string_types))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (isinstance(marker, list) and len(marker) == 1 and
+            isinstance(marker[0], (list, tuple))):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+def _eval_op(lhs, op, rhs):
+    try:
+        spec = Specifier("".join([op.serialize(), rhs]))
+    except InvalidSpecifier:
+        pass
+    else:
+        return spec.contains(lhs)
+
+    oper = _operators.get(op.serialize())
+    if oper is None:
+        raise UndefinedComparison(
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
+        )
+
+    return oper(lhs, rhs)
+
+
+_undefined = object()
+
+
+def _get_env(environment, name):
+    value = environment.get(name, _undefined)
+
+    if value is _undefined:
+        raise UndefinedEnvironmentName(
+            "{0!r} does not exist in evaluation environment.".format(name)
+        )
+
+    return value
+
+
+def _evaluate_markers(markers, environment):
+    groups = [[]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, string_types))
+
+        if isinstance(marker, list):
+            groups[-1].append(_evaluate_markers(marker, environment))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            if isinstance(lhs, Variable):
+                lhs_value = _get_env(environment, lhs.value)
+                rhs_value = rhs.value
+            else:
+                lhs_value = lhs.value
+                rhs_value = _get_env(environment, rhs.value)
+
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return any(all(item) for item in groups)
+
+
+def format_full_version(info):
+    version = '{0.major}.{0.minor}.{0.micro}'.format(info)
+    kind = info.releaselevel
+    if kind != 'final':
+        version += kind[0] + str(info.serial)
+    return version
+
+
+def default_environment():
+    if hasattr(sys, 'implementation'):
+        iver = format_full_version(sys.implementation.version)
+        implementation_name = sys.implementation.name
+    else:
+        iver = '0'
+        implementation_name = ''
+
+    return {
+        "implementation_name": implementation_name,
+        "implementation_version": iver,
+        "os_name": os.name,
+        "platform_machine": platform.machine(),
+        "platform_release": platform.release(),
+        "platform_system": platform.system(),
+        "platform_version": platform.version(),
+        "python_full_version": platform.python_version(),
+        "platform_python_implementation": platform.python_implementation(),
+        "python_version": platform.python_version()[:3],
+        "sys_platform": sys.platform,
+    }
+
+
+class Marker(object):
+
+    def __init__(self, marker):
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+                marker, marker[e.loc:e.loc + 8])
+            raise InvalidMarker(err_str)
+
+    def __str__(self):
+        return _format_marker(self._markers)
+
+    def __repr__(self):
+        return "<Marker({0!r})>".format(str(self))
+
+    def evaluate(self, environment=None):
+        """Evaluate a marker.
+
+        Return the boolean from evaluating the given marker against the
+        environment. environment is an optional argument to override all or
+        part of the determined environment.
+
+        The environment is determined from the current Python process.
+        """
+        current_environment = default_environment()
+        if environment is not None:
+            current_environment.update(environment)
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/requirements.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/requirements.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c8c4a3852fd37053fd552846aa7787805c30a48
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/requirements.py
@@ -0,0 +1,127 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import string
+import re
+
+from pkg_resources.extern.pyparsing import stringStart, stringEnd, originalTextFor, ParseException
+from pkg_resources.extern.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
+from pkg_resources.extern.pyparsing import Literal as L  # noqa
+from pkg_resources.extern.six.moves.urllib import parse as urlparse
+
+from .markers import MARKER_EXPR, Marker
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r'[^ ]+')("url")
+URL = (AT + URI)
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE),
+                       joinString=",", adjacent=False)("_raw_spec")
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '')
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start:t._original_end])
+)
+MARKER_SEPERATOR = SEMICOLON
+MARKER = MARKER_SEPERATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = \
+    NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+
+
+class Requirement(object):
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    # TODO: Can we test whether something is contained within a requirement?
+    #       If so how do we do that? Do we need to test against the _name_ of
+    #       the thing as well as the version? What about the markers?
+    # TODO: Can we normalize the name and extra name?
+
+    def __init__(self, requirement_string):
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                "Invalid requirement, parse error at \"{0!r}\"".format(
+                    requirement_string[e.loc:e.loc + 8]))
+
+        self.name = req.name
+        if req.url:
+            parsed_url = urlparse.urlparse(req.url)
+            if not (parsed_url.scheme and parsed_url.netloc) or (
+                    not parsed_url.scheme and not parsed_url.netloc):
+                raise InvalidRequirement("Invalid URL given")
+            self.url = req.url
+        else:
+            self.url = None
+        self.extras = set(req.extras.asList() if req.extras else [])
+        self.specifier = SpecifierSet(req.specifier)
+        self.marker = req.marker if req.marker else None
+
+    def __str__(self):
+        parts = [self.name]
+
+        if self.extras:
+            parts.append("[{0}]".format(",".join(sorted(self.extras))))
+
+        if self.specifier:
+            parts.append(str(self.specifier))
+
+        if self.url:
+            parts.append("@ {0}".format(self.url))
+
+        if self.marker:
+            parts.append("; {0}".format(self.marker))
+
+        return "".join(parts)
+
+    def __repr__(self):
+        return "<Requirement({0!r})>".format(str(self))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/specifiers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/specifiers.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f5a76cfd63f47dcce29b3ea82f59d10f4e8d771
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/specifiers.py
@@ -0,0 +1,774 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import abc
+import functools
+import itertools
+import re
+
+from ._compat import string_types, with_metaclass
+from .version import Version, LegacyVersion, parse
+
+
+class InvalidSpecifier(ValueError):
+    """
+    An invalid specifier was found, users should refer to PEP 440.
+    """
+
+
+class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):
+
+    @abc.abstractmethod
+    def __str__(self):
+        """
+        Returns the str representation of this Specifier like object. This
+        should be representative of the Specifier itself.
+        """
+
+    @abc.abstractmethod
+    def __hash__(self):
+        """
+        Returns a hash value for this Specifier like object.
+        """
+
+    @abc.abstractmethod
+    def __eq__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are equal.
+        """
+
+    @abc.abstractmethod
+    def __ne__(self, other):
+        """
+        Returns a boolean representing whether or not the two Specifier like
+        objects are not equal.
+        """
+
+    @abc.abstractproperty
+    def prereleases(self):
+        """
+        Returns whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @prereleases.setter
+    def prereleases(self, value):
+        """
+        Sets whether or not pre-releases as a whole are allowed by this
+        specifier.
+        """
+
+    @abc.abstractmethod
+    def contains(self, item, prereleases=None):
+        """
+        Determines if the given item is contained within this specifier.
+        """
+
+    @abc.abstractmethod
+    def filter(self, iterable, prereleases=None):
+        """
+        Takes an iterable of items and filters them so that only items which
+        are contained within this specifier are allowed in it.
+        """
+
+
+class _IndividualSpecifier(BaseSpecifier):
+
+    _operators = {}
+
+    def __init__(self, spec="", prereleases=None):
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
+
+        self._spec = (
+            match.group("operator").strip(),
+            match.group("version").strip(),
+        )
+
+        # Store whether or not this Specifier should accept prereleases
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<{0}({1!r}{2})>".format(
+            self.__class__.__name__,
+            str(self),
+            pre,
+        )
+
+    def __str__(self):
+        return "{0}{1}".format(*self._spec)
+
+    def __hash__(self):
+        return hash(self._spec)
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec == other._spec
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            try:
+                other = self.__class__(other)
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._spec != other._spec
+
+    def _get_operator(self, op):
+        return getattr(self, "_compare_{0}".format(self._operators[op]))
+
+    def _coerce_version(self, version):
+        if not isinstance(version, (LegacyVersion, Version)):
+            version = parse(version)
+        return version
+
+    @property
+    def operator(self):
+        return self._spec[0]
+
+    @property
+    def version(self):
+        return self._spec[1]
+
+    @property
+    def prereleases(self):
+        return self._prereleases
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Determine if prereleases are to be allowed or not.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # Normalize item to a Version or LegacyVersion, this allows us to have
+        # a shortcut for ``"2.0" in Specifier(">=2")
+        item = self._coerce_version(item)
+
+        # Determine if we should be supporting prereleases in this specifier
+        # or not, if we do not support prereleases than we can short circuit
+        # logic if this version is a prereleases.
+        if item.is_prerelease and not prereleases:
+            return False
+
+        # Actually do the comparison to determine if this item is contained
+        # within this Specifier or not.
+        return self._get_operator(self.operator)(item, self.version)
+
+    def filter(self, iterable, prereleases=None):
+        yielded = False
+        found_prereleases = []
+
+        kw = {"prereleases": prereleases if prereleases is not None else True}
+
+        # Attempt to iterate over all the values in the iterable and if any of
+        # them match, yield them.
+        for version in iterable:
+            parsed_version = self._coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                # If our version is a prerelease, and we were not set to allow
+                # prereleases, then we'll store it for later incase nothing
+                # else matches this specifier.
+                if (parsed_version.is_prerelease and not
+                        (prereleases or self.prereleases)):
+                    found_prereleases.append(version)
+                # Either this is not a prerelease, or we should have been
+                # accepting prereleases from the begining.
+                else:
+                    yielded = True
+                    yield version
+
+        # Now that we've iterated over everything, determine if we've yielded
+        # any values, and if we have not and we have any prereleases stored up
+        # then we will go ahead and yield the prereleases.
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+class LegacySpecifier(_IndividualSpecifier):
+
+    _regex_str = (
+        r"""
+        (?P<operator>(==|!=|<=|>=|<|>))
+        \s*
+        (?P<version>
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                      # string can be just about anything, we match everything
+                      # except for whitespace, a semi-colon for marker support,
+                      # a closing paren since versions can be enclosed in
+                      # them, and a comma since it's a version separator.
+        )
+        """
+    )
+
+    _regex = re.compile(
+        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+    }
+
+    def _coerce_version(self, version):
+        if not isinstance(version, LegacyVersion):
+            version = LegacyVersion(str(version))
+        return version
+
+    def _compare_equal(self, prospective, spec):
+        return prospective == self._coerce_version(spec)
+
+    def _compare_not_equal(self, prospective, spec):
+        return prospective != self._coerce_version(spec)
+
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= self._coerce_version(spec)
+
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= self._coerce_version(spec)
+
+    def _compare_less_than(self, prospective, spec):
+        return prospective < self._coerce_version(spec)
+
+    def _compare_greater_than(self, prospective, spec):
+        return prospective > self._coerce_version(spec)
+
+
+def _require_version_compare(fn):
+    @functools.wraps(fn)
+    def wrapped(self, prospective, spec):
+        if not isinstance(prospective, Version):
+            return False
+        return fn(self, prospective, spec)
+    return wrapped
+
+
+class Specifier(_IndividualSpecifier):
+
+    _regex_str = (
+        r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        (?P<version>
+            (?:
+                # The identity operators allow for an escape hatch that will
+                # do an exact string match of the version you wish to install.
+                # This will not be parsed by PEP 440 and we cannot determine
+                # any semantic meaning from it. This operator is discouraged
+                # but included entirely as an escape hatch.
+                (?<====)  # Only match for the identity operator
+                \s*
+                [^\s]*    # We just match everything, except for whitespace
+                          # since we are only testing for strict identity.
+            )
+            |
+            (?:
+                # The (non)equality operators allow for wild card and local
+                # versions to be specified so we have to define these two
+                # operators separately to enable that.
+                (?<===|!=)            # Only match for equals and not equals
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+
+                # You cannot use a wild card and a dev or local version
+                # together so group them with a | and make them optional.
+                (?:
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                    |
+                    \.\*  # Wild card syntax of .*
+                )?
+            )
+            |
+            (?:
+                # The compatible operator requires at least two digits in the
+                # release segment.
+                (?<=~=)               # Only match for the compatible operator
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+            |
+            (?:
+                # All other operators only allow a sub set of what the
+                # (non)equality operators do. Specifically they do not allow
+                # local versions to be specified nor do they allow the prefix
+                # matching wild cards.
+                (?<!==|!=|~=)         # We have special cases for these
+                                      # operators so we want to make sure they
+                                      # don't match here.
+
+                \s*
+                v?
+                (?:[0-9]+!)?          # epoch
+                [0-9]+(?:\.[0-9]+)*   # release
+                (?:                   # pre release
+                    [-_\.]?
+                    (a|b|c|rc|alpha|beta|pre|preview)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:                                   # post release
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+            )
+        )
+        """
+    )
+
+    _regex = re.compile(
+        r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+    _operators = {
+        "~=": "compatible",
+        "==": "equal",
+        "!=": "not_equal",
+        "<=": "less_than_equal",
+        ">=": "greater_than_equal",
+        "<": "less_than",
+        ">": "greater_than",
+        "===": "arbitrary",
+    }
+
+    @_require_version_compare
+    def _compare_compatible(self, prospective, spec):
+        # Compatible releases have an equivalent combination of >= and ==. That
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
+        # implement this in terms of the other specifiers instead of
+        # implementing it ourselves. The only thing we need to do is construct
+        # the other specifiers.
+
+        # We want everything but the last item in the version, but we want to
+        # ignore post and dev releases and we want to treat the pre-release as
+        # it's own separate segment.
+        prefix = ".".join(
+            list(
+                itertools.takewhile(
+                    lambda x: (not x.startswith("post") and not
+                               x.startswith("dev")),
+                    _version_split(spec),
+                )
+            )[:-1]
+        )
+
+        # Add the prefix notation to the end of our string
+        prefix += ".*"
+
+        return (self._get_operator(">=")(prospective, spec) and
+                self._get_operator("==")(prospective, prefix))
+
+    @_require_version_compare
+    def _compare_equal(self, prospective, spec):
+        # We need special logic to handle prefix matching
+        if spec.endswith(".*"):
+            # In the case of prefix matching we want to ignore local segment.
+            prospective = Version(prospective.public)
+            # Split the spec out by dots, and pretend that there is an implicit
+            # dot in between a release segment and a pre-release segment.
+            spec = _version_split(spec[:-2])  # Remove the trailing .*
+
+            # Split the prospective version out by dots, and pretend that there
+            # is an implicit dot in between a release segment and a pre-release
+            # segment.
+            prospective = _version_split(str(prospective))
+
+            # Shorten the prospective version to be the same length as the spec
+            # so that we can determine if the specifier is a prefix of the
+            # prospective version or not.
+            prospective = prospective[:len(spec)]
+
+            # Pad out our two sides with zeros so that they both equal the same
+            # length.
+            spec, prospective = _pad_version(spec, prospective)
+        else:
+            # Convert our spec string into a Version
+            spec = Version(spec)
+
+            # If the specifier does not have a local segment, then we want to
+            # act as if the prospective version also does not have a local
+            # segment.
+            if not spec.local:
+                prospective = Version(prospective.public)
+
+        return prospective == spec
+
+    @_require_version_compare
+    def _compare_not_equal(self, prospective, spec):
+        return not self._compare_equal(prospective, spec)
+
+    @_require_version_compare
+    def _compare_less_than_equal(self, prospective, spec):
+        return prospective <= Version(spec)
+
+    @_require_version_compare
+    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective >= Version(spec)
+
+    @_require_version_compare
+    def _compare_less_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
+
+    @_require_version_compare
+    def _compare_greater_than(self, prospective, spec):
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
+        spec = Version(spec)
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is techincally greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
+
+    def _compare_arbitrary(self, prospective, spec):
+        return str(prospective).lower() == str(spec).lower()
+
+    @property
+    def prereleases(self):
+        # If there is an explicit prereleases set for this, then we'll just
+        # blindly use that.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # Look at all of our specifiers and determine if they are inclusive
+        # operators, and if they are if they are including an explicit
+        # prerelease.
+        operator, version = self._spec
+        if operator in ["==", ">=", "<=", "~=", "==="]:
+            # The == specifier can include a trailing .*, if it does we
+            # want to remove before parsing.
+            if operator == "==" and version.endswith(".*"):
+                version = version[:-2]
+
+            # Parse the version, and if it is a pre-release than this
+            # specifier allows pre-releases.
+            if parse(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
+
+
+def _version_split(version):
+    result = []
+    for item in version.split("."):
+        match = _prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _pad_version(left, right):
+    left_split, right_split = [], []
+
+    # Get the release segment of our versions
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    # Get the rest of our versions
+    left_split.append(left[len(left_split[0]):])
+    right_split.append(right[len(right_split[0]):])
+
+    # Insert our padding
+    left_split.insert(
+        1,
+        ["0"] * max(0, len(right_split[0]) - len(left_split[0])),
+    )
+    right_split.insert(
+        1,
+        ["0"] * max(0, len(left_split[0]) - len(right_split[0])),
+    )
+
+    return (
+        list(itertools.chain(*left_split)),
+        list(itertools.chain(*right_split)),
+    )
+
+
+class SpecifierSet(BaseSpecifier):
+
+    def __init__(self, specifiers="", prereleases=None):
+        # Split on , to break each indidivual specifier into it's own item, and
+        # strip each item to remove leading/trailing whitespace.
+        specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
+
+        # Parsed each individual specifier, attempting first to make it a
+        # Specifier and falling back to a LegacySpecifier.
+        parsed = set()
+        for specifier in specifiers:
+            try:
+                parsed.add(Specifier(specifier))
+            except InvalidSpecifier:
+                parsed.add(LegacySpecifier(specifier))
+
+        # Turn our parsed specifiers into a frozen set and save them for later.
+        self._specs = frozenset(parsed)
+
+        # Store our prereleases value so we can use it later to determine if
+        # we accept prereleases or not.
+        self._prereleases = prereleases
+
+    def __repr__(self):
+        pre = (
+            ", prereleases={0!r}".format(self.prereleases)
+            if self._prereleases is not None
+            else ""
+        )
+
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
+
+    def __str__(self):
+        return ",".join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self):
+        return hash(self._specs)
+
+    def __and__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError(
+                "Cannot combine SpecifierSets with True and False prerelease "
+                "overrides."
+            )
+
+        return specifier
+
+    def __eq__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __ne__(self, other):
+        if isinstance(other, string_types):
+            other = SpecifierSet(other)
+        elif isinstance(other, _IndividualSpecifier):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs != other._specs
+
+    def __len__(self):
+        return len(self._specs)
+
+    def __iter__(self):
+        return iter(self._specs)
+
+    @property
+    def prereleases(self):
+        # If we have been given an explicit prerelease modifier, then we'll
+        # pass that through here.
+        if self._prereleases is not None:
+            return self._prereleases
+
+        # If we don't have any specifiers, and we don't have a forced value,
+        # then we'll just return None since we don't know if this should have
+        # pre-releases or not.
+        if not self._specs:
+            return None
+
+        # Otherwise we'll see if any of the given specifiers accept
+        # prereleases, if any of them do we'll return True, otherwise False.
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value):
+        self._prereleases = value
+
+    def __contains__(self, item):
+        return self.contains(item)
+
+    def contains(self, item, prereleases=None):
+        # Ensure that our item is a Version or LegacyVersion instance.
+        if not isinstance(item, (LegacyVersion, Version)):
+            item = parse(item)
+
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # We can determine if we're going to allow pre-releases by looking to
+        # see if any of the underlying items supports them. If none of them do
+        # and this item is a pre-release then we do not allow it and we can
+        # short circuit that here.
+        # Note: This means that 1.0.dev1 would not be contained in something
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
+        if not prereleases and item.is_prerelease:
+            return False
+
+        # We simply dispatch to the underlying specs here to make sure that the
+        # given version is contained within all of them.
+        # Note: This use of all() here means that an empty set of specifiers
+        #       will always return True, this is an explicit design decision.
+        return all(
+            s.contains(item, prereleases=prereleases)
+            for s in self._specs
+        )
+
+    def filter(self, iterable, prereleases=None):
+        # Determine if we're forcing a prerelease or not, if we're not forcing
+        # one for this particular filter call, then we'll use whatever the
+        # SpecifierSet thinks for whether or not we should support prereleases.
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        # If we have any specifiers, then we want to wrap our iterable in the
+        # filter method for each one, this will act as a logical AND amongst
+        # each specifier.
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iterable
+        # If we do not have any specifiers, then we need to have a rough filter
+        # which will filter out any pre-releases, unless there are no final
+        # releases, and which will filter out LegacyVersion in general.
+        else:
+            filtered = []
+            found_prereleases = []
+
+            for item in iterable:
+                # Ensure that we some kind of Version class for this item.
+                if not isinstance(item, (LegacyVersion, Version)):
+                    parsed_version = parse(item)
+                else:
+                    parsed_version = item
+
+                # Filter out any item which is parsed as a LegacyVersion
+                if isinstance(parsed_version, LegacyVersion):
+                    continue
+
+                # Store any item which is a pre-release for later unless we've
+                # already found a final version or we are accepting prereleases
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            # If we've found no items except for pre-releases, then we'll go
+            # ahead and use the pre-releases
+            if not filtered and found_prereleases and prereleases is None:
+                return found_prereleases
+
+            return filtered
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/utils.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..942387cef5d75f299a769b1eb43b6c7679e7a3a0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/utils.py
@@ -0,0 +1,14 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import re
+
+
+_canonicalize_regex = re.compile(r"[-_.]+")
+
+
+def canonicalize_name(name):
+    # This is taken from PEP 503.
+    return _canonicalize_regex.sub("-", name).lower()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..83b5ee8c5efadf22ce2f16ff08c8a8d75f1eb5df
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/version.py
@@ -0,0 +1,393 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import collections
+import itertools
+import re
+
+from ._structures import Infinity
+
+
+__all__ = [
+    "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"
+]
+
+
+_Version = collections.namedtuple(
+    "_Version",
+    ["epoch", "release", "dev", "pre", "post", "local"],
+)
+
+
+def parse(version):
+    """
+    Parse the given version string and return either a :class:`Version` object
+    or a :class:`LegacyVersion` object depending on if the given version is
+    a valid PEP 440 version or a legacy version.
+    """
+    try:
+        return Version(version)
+    except InvalidVersion:
+        return LegacyVersion(version)
+
+
+class InvalidVersion(ValueError):
+    """
+    An invalid version was found, users should refer to PEP 440.
+    """
+
+
+class _BaseVersion(object):
+
+    def __hash__(self):
+        return hash(self._key)
+
+    def __lt__(self, other):
+        return self._compare(other, lambda s, o: s < o)
+
+    def __le__(self, other):
+        return self._compare(other, lambda s, o: s <= o)
+
+    def __eq__(self, other):
+        return self._compare(other, lambda s, o: s == o)
+
+    def __ge__(self, other):
+        return self._compare(other, lambda s, o: s >= o)
+
+    def __gt__(self, other):
+        return self._compare(other, lambda s, o: s > o)
+
+    def __ne__(self, other):
+        return self._compare(other, lambda s, o: s != o)
+
+    def _compare(self, other, method):
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+
+        return method(self._key, other._key)
+
+
+class LegacyVersion(_BaseVersion):
+
+    def __init__(self, version):
+        self._version = str(version)
+        self._key = _legacy_cmpkey(self._version)
+
+    def __str__(self):
+        return self._version
+
+    def __repr__(self):
+        return "<LegacyVersion({0})>".format(repr(str(self)))
+
+    @property
+    def public(self):
+        return self._version
+
+    @property
+    def base_version(self):
+        return self._version
+
+    @property
+    def local(self):
+        return None
+
+    @property
+    def is_prerelease(self):
+        return False
+
+    @property
+    def is_postrelease(self):
+        return False
+
+
+_legacy_version_component_re = re.compile(
+    r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE,
+)
+
+_legacy_version_replacement_map = {
+    "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@",
+}
+
+
+def _parse_version_parts(s):
+    for part in _legacy_version_component_re.split(s):
+        part = _legacy_version_replacement_map.get(part, part)
+
+        if not part or part == ".":
+            continue
+
+        if part[:1] in "0123456789":
+            # pad for numeric comparison
+            yield part.zfill(8)
+        else:
+            yield "*" + part
+
+    # ensure that alpha/beta/candidate are before final
+    yield "*final"
+
+
+def _legacy_cmpkey(version):
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
+    # greater than or equal to 0. This will effectively put the LegacyVersion,
+    # which uses the defacto standard originally implemented by setuptools,
+    # as before all PEP 440 versions.
+    epoch = -1
+
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to
+    # it's adoption of the packaging library.
+    parts = []
+    for part in _parse_version_parts(version.lower()):
+        if part.startswith("*"):
+            # remove "-" before a prerelease tag
+            if part < "*final":
+                while parts and parts[-1] == "*final-":
+                    parts.pop()
+
+            # remove trailing zeros from each series of numeric parts
+            while parts and parts[-1] == "00000000":
+                parts.pop()
+
+        parts.append(part)
+    parts = tuple(parts)
+
+    return epoch, parts
+
+# Deliberately not anchored to the start and end of the string, to make it
+# easier for 3rd party code to reuse
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(
+        r"^\s*" + VERSION_PATTERN + r"\s*$",
+        re.VERBOSE | re.IGNORECASE,
+    )
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # Store the parsed out pieces of the version
+        self._version = _Version(
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+            release=tuple(int(i) for i in match.group("release").split(".")),
+            pre=_parse_letter_version(
+                match.group("pre_l"),
+                match.group("pre_n"),
+            ),
+            post=_parse_letter_version(
+                match.group("post_l"),
+                match.group("post_n1") or match.group("post_n2"),
+            ),
+            dev=_parse_letter_version(
+                match.group("dev_l"),
+                match.group("dev_n"),
+            ),
+            local=_parse_local_version(match.group("local")),
+        )
+
+        # Generate a key which will be used for sorting
+        self._key = _cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
+
+    def __repr__(self):
+        return "<Version({0})>".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        # Pre-release
+        if self._version.pre is not None:
+            parts.append("".join(str(x) for x in self._version.pre))
+
+        # Post-release
+        if self._version.post is not None:
+            parts.append(".post{0}".format(self._version.post[1]))
+
+        # Development release
+        if self._version.dev is not None:
+            parts.append(".dev{0}".format(self._version.dev[1]))
+
+        # Local version segment
+        if self._version.local is not None:
+            parts.append(
+                "+{0}".format(".".join(str(x) for x in self._version.local))
+            )
+
+        return "".join(parts)
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        return "".join(parts)
+
+    @property
+    def local(self):
+        version_string = str(self)
+        if "+" in version_string:
+            return version_string.split("+", 1)[1]
+
+    @property
+    def is_prerelease(self):
+        return bool(self._version.dev or self._version.pre)
+
+    @property
+    def is_postrelease(self):
+        return bool(self._version.post)
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We consider there to be an implicit 0 in a pre-release if there is
+        # not a numeral associated with it.
+        if number is None:
+            number = 0
+
+        # We normalize any letters to their lower case form
+        letter = letter.lower()
+
+        # We consider some words to be alternate spellings of other words and
+        # in those cases we want to normalize the spellings to our preferred
+        # spelling.
+        if letter == "alpha":
+            letter = "a"
+        elif letter == "beta":
+            letter = "b"
+        elif letter in ["c", "pre", "preview"]:
+            letter = "rc"
+        elif letter in ["rev", "r"]:
+            letter = "post"
+
+        return letter, int(number)
+    if not letter and number:
+        # We assume if we are given a number, but we are not given a letter
+        # then this is using the implicit post release syntax (e.g. 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_seperators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+    """
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_seperators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # When we compare a release version, we want to compare it with all of the
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now
+    # leading zeros until we come to something non zero, then take the rest
+    # re-reverse it back into the correct order and make it a tuple and use
+    # that for our sorting key.
+    release = tuple(
+        reversed(list(
+            itertools.dropwhile(
+                lambda x: x == 0,
+                reversed(release),
+            )
+        ))
+    )
+
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+    # We'll do this by abusing the pre segment, but we _only_ want to do this
+    # if there is not a pre or a post segment. If we have one of those then
+    # the normal sorting rules will handle this case correctly.
+    if pre is None and post is None and dev is not None:
+        pre = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alpha numeric segments sort before numeric segments
+        # - Alpha numeric segments sort lexicographically
+        # - Numeric segments sort numerically
+        # - Shorter versions sort before longer versions when the prefixes
+        #   match exactly
+        local = tuple(
+            (i, "") if isinstance(i, int) else (-Infinity, i)
+            for i in local
+        )
+
+    return epoch, release, pre, post, dev, local
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/pyparsing.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/pyparsing.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf75e1e5fcbfe7eac41d2a9e446c5c980741087b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/pyparsing.py
@@ -0,0 +1,5742 @@
+# module pyparsing.py
+#
+# Copyright (c) 2003-2018  Paul T. McGuire
+#
+# 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.
+#
+
+__doc__ = \
+"""
+pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
+
+The pyparsing module is an alternative approach to creating and executing simple grammars,
+vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
+don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
+provides a library of classes that you use to construct the grammar directly in Python.
+
+Here is a program to parse "Hello, World!" (or any greeting of the form 
+C{"<salutation>, <addressee>!"}), built up using L{Word}, L{Literal}, and L{And} elements 
+(L{'+'<ParserElement.__add__>} operator gives L{And} expressions, strings are auto-converted to
+L{Literal} expressions)::
+
+    from pyparsing import Word, alphas
+
+    # define grammar of a greeting
+    greet = Word(alphas) + "," + Word(alphas) + "!"
+
+    hello = "Hello, World!"
+    print (hello, "->", greet.parseString(hello))
+
+The program outputs the following::
+
+    Hello, World! -> ['Hello', ',', 'World', '!']
+
+The Python representation of the grammar is quite readable, owing to the self-explanatory
+class names, and the use of '+', '|' and '^' operators.
+
+The L{ParseResults} object returned from L{ParserElement.parseString<ParserElement.parseString>} can be accessed as a nested list, a dictionary, or an
+object with named attributes.
+
+The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
+ - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
+ - quoted strings
+ - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
+ - construct character word-group expressions using the L{Word} class
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
+ - associate names with your parsed results using L{ParserElement.setResultsName}
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
+ - find more useful common expressions in the L{pyparsing_common} namespace class
+"""
+
+__version__ = "2.2.1"
+__versionTime__ = "18 Sep 2018 00:49 UTC"
+__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
+
+import string
+from weakref import ref as wkref
+import copy
+import sys
+import warnings
+import re
+import sre_constants
+import collections
+import pprint
+import traceback
+import types
+from datetime import datetime
+
+try:
+    from _thread import RLock
+except ImportError:
+    from threading import RLock
+
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping
+
+try:
+    from collections import OrderedDict as _OrderedDict
+except ImportError:
+    try:
+        from ordereddict import OrderedDict as _OrderedDict
+    except ImportError:
+        _OrderedDict = None
+
+#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
+
+__all__ = [
+'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
+'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
+'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
+'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
+'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
+'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 
+'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
+'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
+'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
+'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
+'htmlComment', 'javaStyleComment', 'line', 'lineEnd', 'lineStart', 'lineno',
+'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
+'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
+'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
+'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
+'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
+'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
+'CloseMatch', 'tokenMap', 'pyparsing_common',
+]
+
+system_version = tuple(sys.version_info)[:3]
+PY_3 = system_version[0] == 3
+if PY_3:
+    _MAX_INT = sys.maxsize
+    basestring = str
+    unichr = chr
+    _ustr = str
+
+    # build list of single arg builtins, that can be used as parse actions
+    singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
+
+else:
+    _MAX_INT = sys.maxint
+    range = xrange
+
+    def _ustr(obj):
+        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
+           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
+           then < returns the unicode object | encodes it with the default encoding | ... >.
+        """
+        if isinstance(obj,unicode):
+            return obj
+
+        try:
+            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
+            # it won't break any existing code.
+            return str(obj)
+
+        except UnicodeEncodeError:
+            # Else encode it
+            ret = unicode(obj).encode(sys.getdefaultencoding(), 'xmlcharrefreplace')
+            xmlcharref = Regex(r'&#\d+;')
+            xmlcharref.setParseAction(lambda t: '\\u' + hex(int(t[0][2:-1]))[2:])
+            return xmlcharref.transformString(ret)
+
+    # build list of single arg builtins, tolerant of Python version, that can be used as parse actions
+    singleArgBuiltins = []
+    import __builtin__
+    for fname in "sum len sorted reversed list tuple set any all min max".split():
+        try:
+            singleArgBuiltins.append(getattr(__builtin__,fname))
+        except AttributeError:
+            continue
+            
+_generatorType = type((y for y in range(1)))
+ 
+def _xml_escape(data):
+    """Escape &, <, >, ", ', etc. in a string of data."""
+
+    # ampersand must be replaced first
+    from_symbols = '&><"\''
+    to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
+    for from_,to_ in zip(from_symbols, to_symbols):
+        data = data.replace(from_, to_)
+    return data
+
+class _Constants(object):
+    pass
+
+alphas     = string.ascii_uppercase + string.ascii_lowercase
+nums       = "0123456789"
+hexnums    = nums + "ABCDEFabcdef"
+alphanums  = alphas + nums
+_bslash    = chr(92)
+printables = "".join(c for c in string.printable if c not in string.whitespace)
+
+class ParseBaseException(Exception):
+    """base exception class for all parsing runtime exceptions"""
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, pstr, loc=0, msg=None, elem=None ):
+        self.loc = loc
+        if msg is None:
+            self.msg = pstr
+            self.pstr = ""
+        else:
+            self.msg = msg
+            self.pstr = pstr
+        self.parserElement = elem
+        self.args = (pstr, loc, msg)
+
+    @classmethod
+    def _from_exception(cls, pe):
+        """
+        internal factory method to simplify creating one type of ParseException 
+        from another - avoids having __init__ signature conflicts among subclasses
+        """
+        return cls(pe.pstr, pe.loc, pe.msg, pe.parserElement)
+
+    def __getattr__( self, aname ):
+        """supported attributes by name are:
+            - lineno - returns the line number of the exception text
+            - col - returns the column number of the exception text
+            - line - returns the line containing the exception text
+        """
+        if( aname == "lineno" ):
+            return lineno( self.loc, self.pstr )
+        elif( aname in ("col", "column") ):
+            return col( self.loc, self.pstr )
+        elif( aname == "line" ):
+            return line( self.loc, self.pstr )
+        else:
+            raise AttributeError(aname)
+
+    def __str__( self ):
+        return "%s (at char %d), (line:%d, col:%d)" % \
+                ( self.msg, self.loc, self.lineno, self.column )
+    def __repr__( self ):
+        return _ustr(self)
+    def markInputline( self, markerString = ">!<" ):
+        """Extracts the exception line from the input string, and marks
+           the location of the exception with a special symbol.
+        """
+        line_str = self.line
+        line_column = self.column - 1
+        if markerString:
+            line_str = "".join((line_str[:line_column],
+                                markerString, line_str[line_column:]))
+        return line_str.strip()
+    def __dir__(self):
+        return "lineno col line".split() + dir(type(self))
+
+class ParseException(ParseBaseException):
+    """
+    Exception thrown when parse expressions don't match class;
+    supported attributes by name are:
+     - lineno - returns the line number of the exception text
+     - col - returns the column number of the exception text
+     - line - returns the line containing the exception text
+        
+    Example::
+        try:
+            Word(nums).setName("integer").parseString("ABC")
+        except ParseException as pe:
+            print(pe)
+            print("column: {}".format(pe.col))
+            
+    prints::
+       Expected integer (at char 0), (line:1, col:1)
+        column: 1
+    """
+    pass
+
+class ParseFatalException(ParseBaseException):
+    """user-throwable exception thrown when inconsistent parse content
+       is found; stops all parsing immediately"""
+    pass
+
+class ParseSyntaxException(ParseFatalException):
+    """just like L{ParseFatalException}, but thrown internally when an
+       L{ErrorStop<And._ErrorStop>} ('-' operator) indicates that parsing is to stop 
+       immediately because an unbacktrackable syntax error has been found"""
+    pass
+
+#~ class ReparseException(ParseBaseException):
+    #~ """Experimental class - parse actions can raise this exception to cause
+       #~ pyparsing to reparse the input string:
+        #~ - with a modified input string, and/or
+        #~ - with a modified start location
+       #~ Set the values of the ReparseException in the constructor, and raise the
+       #~ exception in a parse action to cause pyparsing to use the new string/location.
+       #~ Setting the values as None causes no change to be made.
+       #~ """
+    #~ def __init_( self, newstring, restartLoc ):
+        #~ self.newParseText = newstring
+        #~ self.reparseLoc = restartLoc
+
+class RecursiveGrammarException(Exception):
+    """exception thrown by L{ParserElement.validate} if the grammar could be improperly recursive"""
+    def __init__( self, parseElementList ):
+        self.parseElementTrace = parseElementList
+
+    def __str__( self ):
+        return "RecursiveGrammarException: %s" % self.parseElementTrace
+
+class _ParseResultsWithOffset(object):
+    def __init__(self,p1,p2):
+        self.tup = (p1,p2)
+    def __getitem__(self,i):
+        return self.tup[i]
+    def __repr__(self):
+        return repr(self.tup[0])
+    def setOffset(self,i):
+        self.tup = (self.tup[0],i)
+
+class ParseResults(object):
+    """
+    Structured parse results, to provide multiple means of access to the parsed data:
+       - as a list (C{len(results)})
+       - by list index (C{results[0], results[1]}, etc.)
+       - by attribute (C{results.<resultsName>} - see L{ParserElement.setResultsName})
+
+    Example::
+        integer = Word(nums)
+        date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+        # equivalent form:
+        # date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+
+        # parseString returns a ParseResults object
+        result = date_str.parseString("1999/12/31")
+
+        def test(s, fn=repr):
+            print("%s -> %s" % (s, fn(eval(s))))
+        test("list(result)")
+        test("result[0]")
+        test("result['month']")
+        test("result.day")
+        test("'month' in result")
+        test("'minutes' in result")
+        test("result.dump()", str)
+    prints::
+        list(result) -> ['1999', '/', '12', '/', '31']
+        result[0] -> '1999'
+        result['month'] -> '12'
+        result.day -> '31'
+        'month' in result -> True
+        'minutes' in result -> False
+        result.dump() -> ['1999', '/', '12', '/', '31']
+        - day: 31
+        - month: 12
+        - year: 1999
+    """
+    def __new__(cls, toklist=None, name=None, asList=True, modal=True ):
+        if isinstance(toklist, cls):
+            return toklist
+        retobj = object.__new__(cls)
+        retobj.__doinit = True
+        return retobj
+
+    # Performance tuning: we construct a *lot* of these, so keep this
+    # constructor as small and fast as possible
+    def __init__( self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance ):
+        if self.__doinit:
+            self.__doinit = False
+            self.__name = None
+            self.__parent = None
+            self.__accumNames = {}
+            self.__asList = asList
+            self.__modal = modal
+            if toklist is None:
+                toklist = []
+            if isinstance(toklist, list):
+                self.__toklist = toklist[:]
+            elif isinstance(toklist, _generatorType):
+                self.__toklist = list(toklist)
+            else:
+                self.__toklist = [toklist]
+            self.__tokdict = dict()
+
+        if name is not None and name:
+            if not modal:
+                self.__accumNames[name] = 0
+            if isinstance(name,int):
+                name = _ustr(name) # will always return a str, but use _ustr for consistency
+            self.__name = name
+            if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
+                if isinstance(toklist,basestring):
+                    toklist = [ toklist ]
+                if asList:
+                    if isinstance(toklist,ParseResults):
+                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
+                    else:
+                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
+                    self[name].__name = name
+                else:
+                    try:
+                        self[name] = toklist[0]
+                    except (KeyError,TypeError,IndexError):
+                        self[name] = toklist
+
+    def __getitem__( self, i ):
+        if isinstance( i, (int,slice) ):
+            return self.__toklist[i]
+        else:
+            if i not in self.__accumNames:
+                return self.__tokdict[i][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[i] ])
+
+    def __setitem__( self, k, v, isinstance=isinstance ):
+        if isinstance(v,_ParseResultsWithOffset):
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
+            sub = v[0]
+        elif isinstance(k,(int,slice)):
+            self.__toklist[k] = v
+            sub = v
+        else:
+            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
+            sub = v
+        if isinstance(sub,ParseResults):
+            sub.__parent = wkref(self)
+
+    def __delitem__( self, i ):
+        if isinstance(i,(int,slice)):
+            mylen = len( self.__toklist )
+            del self.__toklist[i]
+
+            # convert int to slice
+            if isinstance(i, int):
+                if i < 0:
+                    i += mylen
+                i = slice(i, i+1)
+            # get removed indices
+            removed = list(range(*i.indices(mylen)))
+            removed.reverse()
+            # fixup indices in token dictionary
+            for name,occurrences in self.__tokdict.items():
+                for j in removed:
+                    for k, (value, position) in enumerate(occurrences):
+                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
+        else:
+            del self.__tokdict[i]
+
+    def __contains__( self, k ):
+        return k in self.__tokdict
+
+    def __len__( self ): return len( self.__toklist )
+    def __bool__(self): return ( not not self.__toklist )
+    __nonzero__ = __bool__
+    def __iter__( self ): return iter( self.__toklist )
+    def __reversed__( self ): return iter( self.__toklist[::-1] )
+    def _iterkeys( self ):
+        if hasattr(self.__tokdict, "iterkeys"):
+            return self.__tokdict.iterkeys()
+        else:
+            return iter(self.__tokdict)
+
+    def _itervalues( self ):
+        return (self[k] for k in self._iterkeys())
+            
+    def _iteritems( self ):
+        return ((k, self[k]) for k in self._iterkeys())
+
+    if PY_3:
+        keys = _iterkeys       
+        """Returns an iterator of all named result keys (Python 3.x only)."""
+
+        values = _itervalues
+        """Returns an iterator of all named result values (Python 3.x only)."""
+
+        items = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 3.x only)."""
+
+    else:
+        iterkeys = _iterkeys
+        """Returns an iterator of all named result keys (Python 2.x only)."""
+
+        itervalues = _itervalues
+        """Returns an iterator of all named result values (Python 2.x only)."""
+
+        iteritems = _iteritems
+        """Returns an iterator of all named result key-value tuples (Python 2.x only)."""
+
+        def keys( self ):
+            """Returns all named result keys (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iterkeys())
+
+        def values( self ):
+            """Returns all named result values (as a list in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.itervalues())
+                
+        def items( self ):
+            """Returns all named result key-values (as a list of tuples in Python 2.x, as an iterator in Python 3.x)."""
+            return list(self.iteritems())
+
+    def haskeys( self ):
+        """Since keys() returns an iterator, this method is helpful in bypassing
+           code that looks for the existence of any defined results names."""
+        return bool(self.__tokdict)
+        
+    def pop( self, *args, **kwargs):
+        """
+        Removes and returns item at specified index (default=C{last}).
+        Supports both C{list} and C{dict} semantics for C{pop()}. If passed no
+        argument or an integer argument, it will use C{list} semantics
+        and pop tokens from the list of parsed tokens. If passed a 
+        non-integer argument (most likely a string), it will use C{dict}
+        semantics and pop the corresponding value from any defined 
+        results names. A second default return value argument is 
+        supported, just as in C{dict.pop()}.
+
+        Example::
+            def remove_first(tokens):
+                tokens.pop(0)
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            print(OneOrMore(Word(nums)).addParseAction(remove_first).parseString("0 123 321")) # -> ['123', '321']
+
+            label = Word(alphas)
+            patt = label("LABEL") + OneOrMore(Word(nums))
+            print(patt.parseString("AAB 123 321").dump())
+
+            # Use pop() in a parse action to remove named result (note that corresponding value is not
+            # removed from list form of results)
+            def remove_LABEL(tokens):
+                tokens.pop("LABEL")
+                return tokens
+            patt.addParseAction(remove_LABEL)
+            print(patt.parseString("AAB 123 321").dump())
+        prints::
+            ['AAB', '123', '321']
+            - LABEL: AAB
+
+            ['AAB', '123', '321']
+        """
+        if not args:
+            args = [-1]
+        for k,v in kwargs.items():
+            if k == 'default':
+                args = (args[0], v)
+            else:
+                raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
+        if (isinstance(args[0], int) or 
+                        len(args) == 1 or 
+                        args[0] in self):
+            index = args[0]
+            ret = self[index]
+            del self[index]
+            return ret
+        else:
+            defaultvalue = args[1]
+            return defaultvalue
+
+    def get(self, key, defaultValue=None):
+        """
+        Returns named result matching the given key, or if there is no
+        such name, then returns the given C{defaultValue} or C{None} if no
+        C{defaultValue} is specified.
+
+        Similar to C{dict.get()}.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            result = date_str.parseString("1999/12/31")
+            print(result.get("year")) # -> '1999'
+            print(result.get("hour", "not specified")) # -> 'not specified'
+            print(result.get("hour")) # -> None
+        """
+        if key in self:
+            return self[key]
+        else:
+            return defaultValue
+
+    def insert( self, index, insStr ):
+        """
+        Inserts new element at location index in the list of parsed tokens.
+        
+        Similar to C{list.insert()}.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+
+            # use a parse action to insert the parse location in the front of the parsed results
+            def insert_locn(locn, tokens):
+                tokens.insert(0, locn)
+            print(OneOrMore(Word(nums)).addParseAction(insert_locn).parseString("0 123 321")) # -> [0, '0', '123', '321']
+        """
+        self.__toklist.insert(index, insStr)
+        # fixup indices in token dictionary
+        for name,occurrences in self.__tokdict.items():
+            for k, (value, position) in enumerate(occurrences):
+                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
+
+    def append( self, item ):
+        """
+        Add single element to end of ParseResults list of elements.
+
+        Example::
+            print(OneOrMore(Word(nums)).parseString("0 123 321")) # -> ['0', '123', '321']
+            
+            # use a parse action to compute the sum of the parsed integers, and add it to the end
+            def append_sum(tokens):
+                tokens.append(sum(map(int, tokens)))
+            print(OneOrMore(Word(nums)).addParseAction(append_sum).parseString("0 123 321")) # -> ['0', '123', '321', 444]
+        """
+        self.__toklist.append(item)
+
+    def extend( self, itemseq ):
+        """
+        Add sequence of elements to end of ParseResults list of elements.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            
+            # use a parse action to append the reverse of the matched strings, to make a palindrome
+            def make_palindrome(tokens):
+                tokens.extend(reversed([t[::-1] for t in tokens]))
+                return ''.join(tokens)
+            print(patt.addParseAction(make_palindrome).parseString("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
+        """
+        if isinstance(itemseq, ParseResults):
+            self += itemseq
+        else:
+            self.__toklist.extend(itemseq)
+
+    def clear( self ):
+        """
+        Clear all elements and results names.
+        """
+        del self.__toklist[:]
+        self.__tokdict.clear()
+
+    def __getattr__( self, name ):
+        try:
+            return self[name]
+        except KeyError:
+            return ""
+            
+        if name in self.__tokdict:
+            if name not in self.__accumNames:
+                return self.__tokdict[name][-1][0]
+            else:
+                return ParseResults([ v[0] for v in self.__tokdict[name] ])
+        else:
+            return ""
+
+    def __add__( self, other ):
+        ret = self.copy()
+        ret += other
+        return ret
+
+    def __iadd__( self, other ):
+        if other.__tokdict:
+            offset = len(self.__toklist)
+            addoffset = lambda a: offset if a<0 else a+offset
+            otheritems = other.__tokdict.items()
+            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
+                                for (k,vlist) in otheritems for v in vlist]
+            for k,v in otherdictitems:
+                self[k] = v
+                if isinstance(v[0],ParseResults):
+                    v[0].__parent = wkref(self)
+            
+        self.__toklist += other.__toklist
+        self.__accumNames.update( other.__accumNames )
+        return self
+
+    def __radd__(self, other):
+        if isinstance(other,int) and other == 0:
+            # useful for merging many ParseResults using sum() builtin
+            return self.copy()
+        else:
+            # this may raise a TypeError - so be it
+            return other + self
+        
+    def __repr__( self ):
+        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
+
+    def __str__( self ):
+        return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
+
+    def _asStringList( self, sep='' ):
+        out = []
+        for item in self.__toklist:
+            if out and sep:
+                out.append(sep)
+            if isinstance( item, ParseResults ):
+                out += item._asStringList()
+            else:
+                out.append( _ustr(item) )
+        return out
+
+    def asList( self ):
+        """
+        Returns the parse results as a nested list of matching tokens, all converted to strings.
+
+        Example::
+            patt = OneOrMore(Word(alphas))
+            result = patt.parseString("sldkj lsdkj sldkj")
+            # even though the result prints in string-like form, it is actually a pyparsing ParseResults
+            print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
+            
+            # Use asList() to create an actual list
+            result_list = result.asList()
+            print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
+        """
+        return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]
+
+    def asDict( self ):
+        """
+        Returns the named parse results as a nested dictionary.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
+            
+            result_dict = result.asDict()
+            print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
+
+            # even though a ParseResults supports dict-like access, sometime you just need to have a dict
+            import json
+            print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
+            print(json.dumps(result.asDict())) # -> {"month": "31", "day": "1999", "year": "12"}
+        """
+        if PY_3:
+            item_fn = self.items
+        else:
+            item_fn = self.iteritems
+            
+        def toItem(obj):
+            if isinstance(obj, ParseResults):
+                if obj.haskeys():
+                    return obj.asDict()
+                else:
+                    return [toItem(v) for v in obj]
+            else:
+                return obj
+                
+        return dict((k,toItem(v)) for k,v in item_fn())
+
+    def copy( self ):
+        """
+        Returns a new copy of a C{ParseResults} object.
+        """
+        ret = ParseResults( self.__toklist )
+        ret.__tokdict = self.__tokdict.copy()
+        ret.__parent = self.__parent
+        ret.__accumNames.update( self.__accumNames )
+        ret.__name = self.__name
+        return ret
+
+    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
+        """
+        (Deprecated) Returns the parse results as XML. Tags are created for tokens and lists that have defined results names.
+        """
+        nl = "\n"
+        out = []
+        namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
+                                                            for v in vlist)
+        nextLevelIndent = indent + "  "
+
+        # collapse out indents if formatting is not desired
+        if not formatted:
+            indent = ""
+            nextLevelIndent = ""
+            nl = ""
+
+        selfTag = None
+        if doctag is not None:
+            selfTag = doctag
+        else:
+            if self.__name:
+                selfTag = self.__name
+
+        if not selfTag:
+            if namedItemsOnly:
+                return ""
+            else:
+                selfTag = "ITEM"
+
+        out += [ nl, indent, "<", selfTag, ">" ]
+
+        for i,res in enumerate(self.__toklist):
+            if isinstance(res,ParseResults):
+                if i in namedItems:
+                    out += [ res.asXML(namedItems[i],
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+                else:
+                    out += [ res.asXML(None,
+                                        namedItemsOnly and doctag is None,
+                                        nextLevelIndent,
+                                        formatted)]
+            else:
+                # individual token, see if there is a name for it
+                resTag = None
+                if i in namedItems:
+                    resTag = namedItems[i]
+                if not resTag:
+                    if namedItemsOnly:
+                        continue
+                    else:
+                        resTag = "ITEM"
+                xmlBodyText = _xml_escape(_ustr(res))
+                out += [ nl, nextLevelIndent, "<", resTag, ">",
+                                                xmlBodyText,
+                                                "</", resTag, ">" ]
+
+        out += [ nl, indent, "</", selfTag, ">" ]
+        return "".join(out)
+
+    def __lookup(self,sub):
+        for k,vlist in self.__tokdict.items():
+            for v,loc in vlist:
+                if sub is v:
+                    return k
+        return None
+
+    def getName(self):
+        r"""
+        Returns the results name for this token expression. Useful when several 
+        different expressions might match at a particular location.
+
+        Example::
+            integer = Word(nums)
+            ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
+            house_number_expr = Suppress('#') + Word(nums, alphanums)
+            user_data = (Group(house_number_expr)("house_number") 
+                        | Group(ssn_expr)("ssn")
+                        | Group(integer)("age"))
+            user_info = OneOrMore(user_data)
+            
+            result = user_info.parseString("22 111-22-3333 #221B")
+            for item in result:
+                print(item.getName(), ':', item[0])
+        prints::
+            age : 22
+            ssn : 111-22-3333
+            house_number : 221B
+        """
+        if self.__name:
+            return self.__name
+        elif self.__parent:
+            par = self.__parent()
+            if par:
+                return par.__lookup(self)
+            else:
+                return None
+        elif (len(self) == 1 and
+               len(self.__tokdict) == 1 and
+               next(iter(self.__tokdict.values()))[0][1] in (0,-1)):
+            return next(iter(self.__tokdict.keys()))
+        else:
+            return None
+
+    def dump(self, indent='', depth=0, full=True):
+        """
+        Diagnostic method for listing out the contents of a C{ParseResults}.
+        Accepts an optional C{indent} argument so that this string can be embedded
+        in a nested display of other data.
+
+        Example::
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+            
+            result = date_str.parseString('12/31/1999')
+            print(result.dump())
+        prints::
+            ['12', '/', '31', '/', '1999']
+            - day: 1999
+            - month: 31
+            - year: 12
+        """
+        out = []
+        NL = '\n'
+        out.append( indent+_ustr(self.asList()) )
+        if full:
+            if self.haskeys():
+                items = sorted((str(k), v) for k,v in self.items())
+                for k,v in items:
+                    if out:
+                        out.append(NL)
+                    out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
+                    if isinstance(v,ParseResults):
+                        if v:
+                            out.append( v.dump(indent,depth+1) )
+                        else:
+                            out.append(_ustr(v))
+                    else:
+                        out.append(repr(v))
+            elif any(isinstance(vv,ParseResults) for vv in self):
+                v = self
+                for i,vv in enumerate(v):
+                    if isinstance(vv,ParseResults):
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),vv.dump(indent,depth+1) ))
+                    else:
+                        out.append("\n%s%s[%d]:\n%s%s%s" % (indent,('  '*(depth)),i,indent,('  '*(depth+1)),_ustr(vv)))
+            
+        return "".join(out)
+
+    def pprint(self, *args, **kwargs):
+        """
+        Pretty-printer for parsed results as a list, using the C{pprint} module.
+        Accepts additional positional or keyword args as defined for the 
+        C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})
+
+        Example::
+            ident = Word(alphas, alphanums)
+            num = Word(nums)
+            func = Forward()
+            term = ident | num | Group('(' + func + ')')
+            func <<= ident + Group(Optional(delimitedList(term)))
+            result = func.parseString("fna a,b,(fnb c,d,200),100")
+            result.pprint(width=40)
+        prints::
+            ['fna',
+             ['a',
+              'b',
+              ['(', 'fnb', ['c', 'd', '200'], ')'],
+              '100']]
+        """
+        pprint.pprint(self.asList(), *args, **kwargs)
+
+    # add support for pickle protocol
+    def __getstate__(self):
+        return ( self.__toklist,
+                 ( self.__tokdict.copy(),
+                   self.__parent is not None and self.__parent() or None,
+                   self.__accumNames,
+                   self.__name ) )
+
+    def __setstate__(self,state):
+        self.__toklist = state[0]
+        (self.__tokdict,
+         par,
+         inAccumNames,
+         self.__name) = state[1]
+        self.__accumNames = {}
+        self.__accumNames.update(inAccumNames)
+        if par is not None:
+            self.__parent = wkref(par)
+        else:
+            self.__parent = None
+
+    def __getnewargs__(self):
+        return self.__toklist, self.__name, self.__asList, self.__modal
+
+    def __dir__(self):
+        return (dir(type(self)) + list(self.keys()))
+
+MutableMapping.register(ParseResults)
+
+def col (loc,strg):
+    """Returns current column within a string, counting newlines as line separators.
+   The first column is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    s = strg
+    return 1 if 0<loc<len(s) and s[loc-1] == '\n' else loc - s.rfind("\n", 0, loc)
+
+def lineno(loc,strg):
+    """Returns current line number within a string, counting newlines as line separators.
+   The first line is number 1.
+
+   Note: the default parsing behavior is to expand tabs in the input string
+   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
+   on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+   consistent view of the parsed string, the parse location, and line and column
+   positions within the parsed string.
+   """
+    return strg.count("\n",0,loc) + 1
+
+def line( loc, strg ):
+    """Returns the line of text containing loc within a string, counting newlines as line separators.
+       """
+    lastCR = strg.rfind("\n", 0, loc)
+    nextCR = strg.find("\n", loc)
+    if nextCR >= 0:
+        return strg[lastCR+1:nextCR]
+    else:
+        return strg[lastCR+1:]
+
+def _defaultStartDebugAction( instring, loc, expr ):
+    print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))
+
+def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
+    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
+
+def _defaultExceptionDebugAction( instring, loc, expr, exc ):
+    print ("Exception raised:" + _ustr(exc))
+
+def nullDebugAction(*args):
+    """'Do-nothing' debug action, to suppress debugging output during parsing."""
+    pass
+
+# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
+#~ 'decorator to trim function calls to match the arity of the target'
+#~ def _trim_arity(func, maxargs=3):
+    #~ if func in singleArgBuiltins:
+        #~ return lambda s,l,t: func(t)
+    #~ limit = 0
+    #~ foundArity = False
+    #~ def wrapper(*args):
+        #~ nonlocal limit,foundArity
+        #~ while 1:
+            #~ try:
+                #~ ret = func(*args[limit:])
+                #~ foundArity = True
+                #~ return ret
+            #~ except TypeError:
+                #~ if limit == maxargs or foundArity:
+                    #~ raise
+                #~ limit += 1
+                #~ continue
+    #~ return wrapper
+
+# this version is Python 2.x-3.x cross-compatible
+'decorator to trim function calls to match the arity of the target'
+def _trim_arity(func, maxargs=2):
+    if func in singleArgBuiltins:
+        return lambda s,l,t: func(t)
+    limit = [0]
+    foundArity = [False]
+    
+    # traceback return data structure changed in Py3.5 - normalize back to plain tuples
+    if system_version[:2] >= (3,5):
+        def extract_stack(limit=0):
+            # special handling for Python 3.5.0 - extra deep call stack by 1
+            offset = -3 if system_version == (3,5,0) else -2
+            frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
+            return [frame_summary[:2]]
+        def extract_tb(tb, limit=0):
+            frames = traceback.extract_tb(tb, limit=limit)
+            frame_summary = frames[-1]
+            return [frame_summary[:2]]
+    else:
+        extract_stack = traceback.extract_stack
+        extract_tb = traceback.extract_tb
+    
+    # synthesize what would be returned by traceback.extract_stack at the call to 
+    # user's parse action 'func', so that we don't incur call penalty at parse time
+    
+    LINE_DIFF = 6
+    # IF ANY CODE CHANGES, EVEN JUST COMMENTS OR BLANK LINES, BETWEEN THE NEXT LINE AND 
+    # THE CALL TO FUNC INSIDE WRAPPER, LINE_DIFF MUST BE MODIFIED!!!!
+    this_line = extract_stack(limit=2)[-1]
+    pa_call_line_synth = (this_line[0], this_line[1]+LINE_DIFF)
+
+    def wrapper(*args):
+        while 1:
+            try:
+                ret = func(*args[limit[0]:])
+                foundArity[0] = True
+                return ret
+            except TypeError:
+                # re-raise TypeErrors if they did not come from our arity testing
+                if foundArity[0]:
+                    raise
+                else:
+                    try:
+                        tb = sys.exc_info()[-1]
+                        if not extract_tb(tb, limit=2)[-1][:2] == pa_call_line_synth:
+                            raise
+                    finally:
+                        del tb
+
+                if limit[0] <= maxargs:
+                    limit[0] += 1
+                    continue
+                raise
+
+    # copy func name to wrapper for sensible debug output
+    func_name = "<parse action>"
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    wrapper.__name__ = func_name
+
+    return wrapper
+
+class ParserElement(object):
+    """Abstract base level parser element class."""
+    DEFAULT_WHITE_CHARS = " \n\t\r"
+    verbose_stacktrace = False
+
+    @staticmethod
+    def setDefaultWhitespaceChars( chars ):
+        r"""
+        Overrides the default whitespace chars
+
+        Example::
+            # default whitespace chars are space, <TAB> and newline
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def', 'ghi', 'jkl']
+            
+            # change to just treat newline as significant
+            ParserElement.setDefaultWhitespaceChars(" \t")
+            OneOrMore(Word(alphas)).parseString("abc def\nghi jkl")  # -> ['abc', 'def']
+        """
+        ParserElement.DEFAULT_WHITE_CHARS = chars
+
+    @staticmethod
+    def inlineLiteralsUsing(cls):
+        """
+        Set class to be used for inclusion of string literals into a parser.
+        
+        Example::
+            # default literal class used is Literal
+            integer = Word(nums)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+
+            # change to Suppress
+            ParserElement.inlineLiteralsUsing(Suppress)
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")           
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '12', '31']
+        """
+        ParserElement._literalStringClass = cls
+
+    def __init__( self, savelist=False ):
+        self.parseAction = list()
+        self.failAction = None
+        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
+        self.strRepr = None
+        self.resultsName = None
+        self.saveAsList = savelist
+        self.skipWhitespace = True
+        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        self.copyDefaultWhiteChars = True
+        self.mayReturnEmpty = False # used when checking for left-recursion
+        self.keepTabs = False
+        self.ignoreExprs = list()
+        self.debug = False
+        self.streamlined = False
+        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
+        self.errmsg = ""
+        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
+        self.debugActions = ( None, None, None ) #custom debug actions
+        self.re = None
+        self.callPreparse = True # used to avoid redundant calls to preParse
+        self.callDuringTry = False
+
+    def copy( self ):
+        """
+        Make a copy of this C{ParserElement}.  Useful for defining different parse actions
+        for the same parsing pattern, using copies of the original parse element.
+        
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
+            integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+            
+            print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
+        prints::
+            [5120, 100, 655360, 268435456]
+        Equivalent form of C{expr.copy()} is just C{expr()}::
+            integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
+        """
+        cpy = copy.copy( self )
+        cpy.parseAction = self.parseAction[:]
+        cpy.ignoreExprs = self.ignoreExprs[:]
+        if self.copyDefaultWhiteChars:
+            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
+        return cpy
+
+    def setName( self, name ):
+        """
+        Define name for this expression, makes debugging and exception messages clearer.
+        
+        Example::
+            Word(nums).parseString("ABC")  # -> Exception: Expected W:(0123...) (at char 0), (line:1, col:1)
+            Word(nums).setName("integer").parseString("ABC")  # -> Exception: Expected integer (at char 0), (line:1, col:1)
+        """
+        self.name = name
+        self.errmsg = "Expected " + self.name
+        if hasattr(self,"exception"):
+            self.exception.msg = self.errmsg
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        """
+        Define name for referencing matching tokens as a nested attribute
+        of the returned parse results.
+        NOTE: this returns a *copy* of the original C{ParserElement} object;
+        this is so that the client can define a basic element, such as an
+        integer, and reference it in multiple places with different names.
+
+        You can also set results names using the abbreviated syntax,
+        C{expr("name")} in place of C{expr.setResultsName("name")} - 
+        see L{I{__call__}<__call__>}.
+
+        Example::
+            date_str = (integer.setResultsName("year") + '/' 
+                        + integer.setResultsName("month") + '/' 
+                        + integer.setResultsName("day"))
+
+            # equivalent form:
+            date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
+        """
+        newself = self.copy()
+        if name.endswith("*"):
+            name = name[:-1]
+            listAllMatches=True
+        newself.resultsName = name
+        newself.modalResults = not listAllMatches
+        return newself
+
+    def setBreak(self,breakFlag = True):
+        """Method to invoke the Python pdb debugger when this element is
+           about to be parsed. Set C{breakFlag} to True to enable, False to
+           disable.
+        """
+        if breakFlag:
+            _parseMethod = self._parse
+            def breaker(instring, loc, doActions=True, callPreParse=True):
+                import pdb
+                pdb.set_trace()
+                return _parseMethod( instring, loc, doActions, callPreParse )
+            breaker._originalParseMethod = _parseMethod
+            self._parse = breaker
+        else:
+            if hasattr(self._parse,"_originalParseMethod"):
+                self._parse = self._parse._originalParseMethod
+        return self
+
+    def setParseAction( self, *fns, **kwargs ):
+        """
+        Define one or more actions to perform when successfully matching parse element definition.
+        Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
+        C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
+         - s   = the original string being parsed (see note below)
+         - loc = the location of the matching substring
+         - toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
+        If the functions in fns modify the tokens, they can return them as the return
+        value from fn, and the modified list of tokens will replace the original.
+        Otherwise, fn does not need to return any value.
+
+        Optional keyword arguments:
+         - callDuringTry = (default=C{False}) indicate if parse action should be run during lookaheads and alternate testing
+
+        Note: the default parsing behavior is to expand tabs in the input string
+        before starting the parsing process.  See L{I{parseString}<parseString>} for more information
+        on parsing strings containing C{<TAB>}s, and suggested methods to maintain a
+        consistent view of the parsed string, the parse location, and line and column
+        positions within the parsed string.
+        
+        Example::
+            integer = Word(nums)
+            date_str = integer + '/' + integer + '/' + integer
+
+            date_str.parseString("1999/12/31")  # -> ['1999', '/', '12', '/', '31']
+
+            # use parse action to convert to ints at parse time
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            date_str = integer + '/' + integer + '/' + integer
+
+            # note that integer fields are now ints, not strings
+            date_str.parseString("1999/12/31")  # -> [1999, '/', 12, '/', 31]
+        """
+        self.parseAction = list(map(_trim_arity, list(fns)))
+        self.callDuringTry = kwargs.get("callDuringTry", False)
+        return self
+
+    def addParseAction( self, *fns, **kwargs ):
+        """
+        Add one or more parse actions to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}.
+        
+        See examples in L{I{copy}<copy>}.
+        """
+        self.parseAction += list(map(_trim_arity, list(fns)))
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def addCondition(self, *fns, **kwargs):
+        """Add a boolean predicate function to expression's list of parse actions. See 
+        L{I{setParseAction}<setParseAction>} for function call signatures. Unlike C{setParseAction}, 
+        functions passed to C{addCondition} need to return boolean success/fail of the condition.
+
+        Optional keyword arguments:
+         - message = define a custom message to be used in the raised exception
+         - fatal   = if True, will raise ParseFatalException to stop parsing immediately; otherwise will raise ParseException
+         
+        Example::
+            integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
+            year_int = integer.copy()
+            year_int.addCondition(lambda toks: toks[0] >= 2000, message="Only support years 2000 and later")
+            date_str = year_int + '/' + integer + '/' + integer
+
+            result = date_str.parseString("1999/12/31")  # -> Exception: Only support years 2000 and later (at char 0), (line:1, col:1)
+        """
+        msg = kwargs.get("message", "failed user-defined condition")
+        exc_type = ParseFatalException if kwargs.get("fatal", False) else ParseException
+        for fn in fns:
+            def pa(s,l,t):
+                if not bool(_trim_arity(fn)(s,l,t)):
+                    raise exc_type(s,l,msg)
+            self.parseAction.append(pa)
+        self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
+        return self
+
+    def setFailAction( self, fn ):
+        """Define action to perform if parsing fails at this expression.
+           Fail acton fn is a callable function that takes the arguments
+           C{fn(s,loc,expr,err)} where:
+            - s = string being parsed
+            - loc = location where expression match was attempted and failed
+            - expr = the parse expression that failed
+            - err = the exception thrown
+           The function returns no value.  It may throw C{L{ParseFatalException}}
+           if it is desired to stop parsing immediately."""
+        self.failAction = fn
+        return self
+
+    def _skipIgnorables( self, instring, loc ):
+        exprsFound = True
+        while exprsFound:
+            exprsFound = False
+            for e in self.ignoreExprs:
+                try:
+                    while 1:
+                        loc,dummy = e._parse( instring, loc )
+                        exprsFound = True
+                except ParseException:
+                    pass
+        return loc
+
+    def preParse( self, instring, loc ):
+        if self.ignoreExprs:
+            loc = self._skipIgnorables( instring, loc )
+
+        if self.skipWhitespace:
+            wt = self.whiteChars
+            instrlen = len(instring)
+            while loc < instrlen and instring[loc] in wt:
+                loc += 1
+
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        return loc, []
+
+    def postParse( self, instring, loc, tokenlist ):
+        return tokenlist
+
+    #~ @profile
+    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
+        debugging = ( self.debug ) #and doActions )
+
+        if debugging or self.failAction:
+            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
+            if (self.debugActions[0] ):
+                self.debugActions[0]( instring, loc, self )
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            try:
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            except ParseBaseException as err:
+                #~ print ("Exception raised:", err)
+                if self.debugActions[2]:
+                    self.debugActions[2]( instring, tokensStart, self, err )
+                if self.failAction:
+                    self.failAction( instring, tokensStart, self, err )
+                raise
+        else:
+            if callPreParse and self.callPreparse:
+                preloc = self.preParse( instring, loc )
+            else:
+                preloc = loc
+            tokensStart = preloc
+            if self.mayIndexError or preloc >= len(instring):
+                try:
+                    loc,tokens = self.parseImpl( instring, preloc, doActions )
+                except IndexError:
+                    raise ParseException( instring, len(instring), self.errmsg, self )
+            else:
+                loc,tokens = self.parseImpl( instring, preloc, doActions )
+
+        tokens = self.postParse( instring, loc, tokens )
+
+        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
+        if self.parseAction and (doActions or self.callDuringTry):
+            if debugging:
+                try:
+                    for fn in self.parseAction:
+                        tokens = fn( instring, tokensStart, retTokens )
+                        if tokens is not None:
+                            retTokens = ParseResults( tokens,
+                                                      self.resultsName,
+                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                      modal=self.modalResults )
+                except ParseBaseException as err:
+                    #~ print "Exception raised in user parse action:", err
+                    if (self.debugActions[2] ):
+                        self.debugActions[2]( instring, tokensStart, self, err )
+                    raise
+            else:
+                for fn in self.parseAction:
+                    tokens = fn( instring, tokensStart, retTokens )
+                    if tokens is not None:
+                        retTokens = ParseResults( tokens,
+                                                  self.resultsName,
+                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
+                                                  modal=self.modalResults )
+        if debugging:
+            #~ print ("Matched",self,"->",retTokens.asList())
+            if (self.debugActions[1] ):
+                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
+
+        return loc, retTokens
+
+    def tryParse( self, instring, loc ):
+        try:
+            return self._parse( instring, loc, doActions=False )[0]
+        except ParseFatalException:
+            raise ParseException( instring, loc, self.errmsg, self)
+    
+    def canParseNext(self, instring, loc):
+        try:
+            self.tryParse(instring, loc)
+        except (ParseException, IndexError):
+            return False
+        else:
+            return True
+
+    class _UnboundedCache(object):
+        def __init__(self):
+            cache = {}
+            self.not_in_cache = not_in_cache = object()
+
+            def get(self, key):
+                return cache.get(key, not_in_cache)
+
+            def set(self, key, value):
+                cache[key] = value
+
+            def clear(self):
+                cache.clear()
+                
+            def cache_len(self):
+                return len(cache)
+
+            self.get = types.MethodType(get, self)
+            self.set = types.MethodType(set, self)
+            self.clear = types.MethodType(clear, self)
+            self.__len__ = types.MethodType(cache_len, self)
+
+    if _OrderedDict is not None:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = _OrderedDict()
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(cache) > size:
+                        try:
+                            cache.popitem(False)
+                        except KeyError:
+                            pass
+
+                def clear(self):
+                    cache.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    else:
+        class _FifoCache(object):
+            def __init__(self, size):
+                self.not_in_cache = not_in_cache = object()
+
+                cache = {}
+                key_fifo = collections.deque([], size)
+
+                def get(self, key):
+                    return cache.get(key, not_in_cache)
+
+                def set(self, key, value):
+                    cache[key] = value
+                    while len(key_fifo) > size:
+                        cache.pop(key_fifo.popleft(), None)
+                    key_fifo.append(key)
+
+                def clear(self):
+                    cache.clear()
+                    key_fifo.clear()
+
+                def cache_len(self):
+                    return len(cache)
+
+                self.get = types.MethodType(get, self)
+                self.set = types.MethodType(set, self)
+                self.clear = types.MethodType(clear, self)
+                self.__len__ = types.MethodType(cache_len, self)
+
+    # argument cache for optimizing repeated calls when backtracking through recursive expressions
+    packrat_cache = {} # this is set later by enabledPackrat(); this is here so that resetCache() doesn't fail
+    packrat_cache_lock = RLock()
+    packrat_cache_stats = [0, 0]
+
+    # this method gets repeatedly called during backtracking with the same arguments -
+    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
+    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
+        HIT, MISS = 0, 1
+        lookup = (self, instring, loc, callPreParse, doActions)
+        with ParserElement.packrat_cache_lock:
+            cache = ParserElement.packrat_cache
+            value = cache.get(lookup)
+            if value is cache.not_in_cache:
+                ParserElement.packrat_cache_stats[MISS] += 1
+                try:
+                    value = self._parseNoCache(instring, loc, doActions, callPreParse)
+                except ParseBaseException as pe:
+                    # cache a copy of the exception, without the traceback
+                    cache.set(lookup, pe.__class__(*pe.args))
+                    raise
+                else:
+                    cache.set(lookup, (value[0], value[1].copy()))
+                    return value
+            else:
+                ParserElement.packrat_cache_stats[HIT] += 1
+                if isinstance(value, Exception):
+                    raise value
+                return (value[0], value[1].copy())
+
+    _parse = _parseNoCache
+
+    @staticmethod
+    def resetCache():
+        ParserElement.packrat_cache.clear()
+        ParserElement.packrat_cache_stats[:] = [0] * len(ParserElement.packrat_cache_stats)
+
+    _packratEnabled = False
+    @staticmethod
+    def enablePackrat(cache_size_limit=128):
+        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
+           Repeated parse attempts at the same string location (which happens
+           often in many complex grammars) can immediately return a cached value,
+           instead of re-executing parsing/validating code.  Memoizing is done of
+           both valid results and parsing exceptions.
+           
+           Parameters:
+            - cache_size_limit - (default=C{128}) - if an integer value is provided
+              will limit the size of the packrat cache; if None is passed, then
+              the cache size will be unbounded; if 0 is passed, the cache will
+              be effectively disabled.
+            
+           This speedup may break existing programs that use parse actions that
+           have side-effects.  For this reason, packrat parsing is disabled when
+           you first import pyparsing.  To activate the packrat feature, your
+           program must call the class method C{ParserElement.enablePackrat()}.  If
+           your program uses C{psyco} to "compile as you go", you must call
+           C{enablePackrat} before calling C{psyco.full()}.  If you do not do this,
+           Python will crash.  For best results, call C{enablePackrat()} immediately
+           after importing pyparsing.
+           
+           Example::
+               import pyparsing
+               pyparsing.ParserElement.enablePackrat()
+        """
+        if not ParserElement._packratEnabled:
+            ParserElement._packratEnabled = True
+            if cache_size_limit is None:
+                ParserElement.packrat_cache = ParserElement._UnboundedCache()
+            else:
+                ParserElement.packrat_cache = ParserElement._FifoCache(cache_size_limit)
+            ParserElement._parse = ParserElement._parseCache
+
+    def parseString( self, instring, parseAll=False ):
+        """
+        Execute the parse expression with the given string.
+        This is the main interface to the client code, once the complete
+        expression has been built.
+
+        If you want the grammar to require that the entire input string be
+        successfully parsed, then set C{parseAll} to True (equivalent to ending
+        the grammar with C{L{StringEnd()}}).
+
+        Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
+        in order to report proper column numbers in parse actions.
+        If the input string contains tabs and
+        the grammar uses parse actions that use the C{loc} argument to index into the
+        string being parsed, you can ensure you have a consistent view of the input
+        string by:
+         - calling C{parseWithTabs} on your grammar before calling C{parseString}
+           (see L{I{parseWithTabs}<parseWithTabs>})
+         - define your parse action using the full C{(s,loc,toks)} signature, and
+           reference the input string using the parse action's C{s} argument
+         - explictly expand the tabs in your input string before calling
+           C{parseString}
+        
+        Example::
+            Word('a').parseString('aaaaabaaa')  # -> ['aaaaa']
+            Word('a').parseString('aaaaabaaa', parseAll=True)  # -> Exception: Expected end of text
+        """
+        ParserElement.resetCache()
+        if not self.streamlined:
+            self.streamline()
+            #~ self.saveAsList = True
+        for e in self.ignoreExprs:
+            e.streamline()
+        if not self.keepTabs:
+            instring = instring.expandtabs()
+        try:
+            loc, tokens = self._parse( instring, 0 )
+            if parseAll:
+                loc = self.preParse( instring, loc )
+                se = Empty() + StringEnd()
+                se._parse( instring, loc )
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+        else:
+            return tokens
+
+    def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
+        """
+        Scan the input string for expression matches.  Each match will return the
+        matching tokens, start location, and end location.  May be called with optional
+        C{maxMatches} argument, to clip scanning after 'n' matches are found.  If
+        C{overlap} is specified, then overlapping matches will be reported.
+
+        Note that the start and end locations are reported relative to the string
+        being parsed.  See L{I{parseString}<parseString>} for more information on parsing
+        strings with embedded tabs.
+
+        Example::
+            source = "sldjf123lsdjjkf345sldkjf879lkjsfd987"
+            print(source)
+            for tokens,start,end in Word(alphas).scanString(source):
+                print(' '*start + '^'*(end-start))
+                print(' '*start + tokens[0])
+        
+        prints::
+        
+            sldjf123lsdjjkf345sldkjf879lkjsfd987
+            ^^^^^
+            sldjf
+                    ^^^^^^^
+                    lsdjjkf
+                              ^^^^^^
+                              sldkjf
+                                       ^^^^^^
+                                       lkjsfd
+        """
+        if not self.streamlined:
+            self.streamline()
+        for e in self.ignoreExprs:
+            e.streamline()
+
+        if not self.keepTabs:
+            instring = _ustr(instring).expandtabs()
+        instrlen = len(instring)
+        loc = 0
+        preparseFn = self.preParse
+        parseFn = self._parse
+        ParserElement.resetCache()
+        matches = 0
+        try:
+            while loc <= instrlen and matches < maxMatches:
+                try:
+                    preloc = preparseFn( instring, loc )
+                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
+                except ParseException:
+                    loc = preloc+1
+                else:
+                    if nextLoc > loc:
+                        matches += 1
+                        yield tokens, preloc, nextLoc
+                        if overlap:
+                            nextloc = preparseFn( instring, loc )
+                            if nextloc > loc:
+                                loc = nextLoc
+                            else:
+                                loc += 1
+                        else:
+                            loc = nextLoc
+                    else:
+                        loc = preloc+1
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def transformString( self, instring ):
+        """
+        Extension to C{L{scanString}}, to modify matching text with modified tokens that may
+        be returned from a parse action.  To use C{transformString}, define a grammar and
+        attach a parse action to it that modifies the returned token list.
+        Invoking C{transformString()} on a target string will then scan for matches,
+        and replace the matched text patterns according to the logic in the parse
+        action.  C{transformString()} returns the resulting transformed string.
+        
+        Example::
+            wd = Word(alphas)
+            wd.setParseAction(lambda toks: toks[0].title())
+            
+            print(wd.transformString("now is the winter of our discontent made glorious summer by this sun of york."))
+        Prints::
+            Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York.
+        """
+        out = []
+        lastE = 0
+        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
+        # keep string locs straight between transformString and scanString
+        self.keepTabs = True
+        try:
+            for t,s,e in self.scanString( instring ):
+                out.append( instring[lastE:s] )
+                if t:
+                    if isinstance(t,ParseResults):
+                        out += t.asList()
+                    elif isinstance(t,list):
+                        out += t
+                    else:
+                        out.append(t)
+                lastE = e
+            out.append(instring[lastE:])
+            out = [o for o in out if o]
+            return "".join(map(_ustr,_flatten(out)))
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def searchString( self, instring, maxMatches=_MAX_INT ):
+        """
+        Another extension to C{L{scanString}}, simplifying the access to the tokens found
+        to match the given parse expression.  May be called with optional
+        C{maxMatches} argument, to clip searching after 'n' matches are found.
+        
+        Example::
+            # a capitalized word starts with an uppercase letter, followed by zero or more lowercase letters
+            cap_word = Word(alphas.upper(), alphas.lower())
+            
+            print(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity"))
+
+            # the sum() builtin can be used to merge results into a single ParseResults object
+            print(sum(cap_word.searchString("More than Iron, more than Lead, more than Gold I need Electricity")))
+        prints::
+            [['More'], ['Iron'], ['Lead'], ['Gold'], ['I'], ['Electricity']]
+            ['More', 'Iron', 'Lead', 'Gold', 'I', 'Electricity']
+        """
+        try:
+            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def split(self, instring, maxsplit=_MAX_INT, includeSeparators=False):
+        """
+        Generator method to split a string using the given expression as a separator.
+        May be called with optional C{maxsplit} argument, to limit the number of splits;
+        and the optional C{includeSeparators} argument (default=C{False}), if the separating
+        matching text should be included in the split results.
+        
+        Example::        
+            punc = oneOf(list(".,;:/-!?"))
+            print(list(punc.split("This, this?, this sentence, is badly punctuated!")))
+        prints::
+            ['This', ' this', '', ' this sentence', ' is badly punctuated', '']
+        """
+        splits = 0
+        last = 0
+        for t,s,e in self.scanString(instring, maxMatches=maxsplit):
+            yield instring[last:s]
+            if includeSeparators:
+                yield t[0]
+            last = e
+        yield instring[last:]
+
+    def __add__(self, other ):
+        """
+        Implementation of + operator - returns C{L{And}}. Adding strings to a ParserElement
+        converts them to L{Literal}s by default.
+        
+        Example::
+            greet = Word(alphas) + "," + Word(alphas) + "!"
+            hello = "Hello, World!"
+            print (hello, "->", greet.parseString(hello))
+        Prints::
+            Hello, World! -> ['Hello', ',', 'World', '!']
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return And( [ self, other ] )
+
+    def __radd__(self, other ):
+        """
+        Implementation of + operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other + self
+
+    def __sub__(self, other):
+        """
+        Implementation of - operator, returns C{L{And}} with error stop
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return self + And._ErrorStop() + other
+
+    def __rsub__(self, other ):
+        """
+        Implementation of - operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other - self
+
+    def __mul__(self,other):
+        """
+        Implementation of * operator, allows use of C{expr * 3} in place of
+        C{expr + expr + expr}.  Expressions may also me multiplied by a 2-integer
+        tuple, similar to C{{min,max}} multipliers in regular expressions.  Tuples
+        may also include C{None} as in:
+         - C{expr*(n,None)} or C{expr*(n,)} is equivalent
+              to C{expr*n + L{ZeroOrMore}(expr)}
+              (read as "at least n instances of C{expr}")
+         - C{expr*(None,n)} is equivalent to C{expr*(0,n)}
+              (read as "0 to n instances of C{expr}")
+         - C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
+         - C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
+
+        Note that C{expr*(None,n)} does not raise an exception if
+        more than n exprs exist in the input stream; that is,
+        C{expr*(None,n)} does not enforce a maximum number of expr
+        occurrences.  If this behavior is desired, then write
+        C{expr*(None,n) + ~expr}
+        """
+        if isinstance(other,int):
+            minElements, optElements = other,0
+        elif isinstance(other,tuple):
+            other = (other + (None, None))[:2]
+            if other[0] is None:
+                other = (0, other[1])
+            if isinstance(other[0],int) and other[1] is None:
+                if other[0] == 0:
+                    return ZeroOrMore(self)
+                if other[0] == 1:
+                    return OneOrMore(self)
+                else:
+                    return self*other[0] + ZeroOrMore(self)
+            elif isinstance(other[0],int) and isinstance(other[1],int):
+                minElements, optElements = other
+                optElements -= minElements
+            else:
+                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
+        else:
+            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
+
+        if minElements < 0:
+            raise ValueError("cannot multiply ParserElement by negative value")
+        if optElements < 0:
+            raise ValueError("second tuple value must be greater or equal to first tuple value")
+        if minElements == optElements == 0:
+            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
+
+        if (optElements):
+            def makeOptionalList(n):
+                if n>1:
+                    return Optional(self + makeOptionalList(n-1))
+                else:
+                    return Optional(self)
+            if minElements:
+                if minElements == 1:
+                    ret = self + makeOptionalList(optElements)
+                else:
+                    ret = And([self]*minElements) + makeOptionalList(optElements)
+            else:
+                ret = makeOptionalList(optElements)
+        else:
+            if minElements == 1:
+                ret = self
+            else:
+                ret = And([self]*minElements)
+        return ret
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __or__(self, other ):
+        """
+        Implementation of | operator - returns C{L{MatchFirst}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return MatchFirst( [ self, other ] )
+
+    def __ror__(self, other ):
+        """
+        Implementation of | operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other | self
+
+    def __xor__(self, other ):
+        """
+        Implementation of ^ operator - returns C{L{Or}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Or( [ self, other ] )
+
+    def __rxor__(self, other ):
+        """
+        Implementation of ^ operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other ^ self
+
+    def __and__(self, other ):
+        """
+        Implementation of & operator - returns C{L{Each}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return Each( [ self, other ] )
+
+    def __rand__(self, other ):
+        """
+        Implementation of & operator when left operand is not a C{L{ParserElement}}
+        """
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        if not isinstance( other, ParserElement ):
+            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
+                    SyntaxWarning, stacklevel=2)
+            return None
+        return other & self
+
+    def __invert__( self ):
+        """
+        Implementation of ~ operator - returns C{L{NotAny}}
+        """
+        return NotAny( self )
+
+    def __call__(self, name=None):
+        """
+        Shortcut for C{L{setResultsName}}, with C{listAllMatches=False}.
+        
+        If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
+        passed as C{True}.
+           
+        If C{name} is omitted, same as calling C{L{copy}}.
+
+        Example::
+            # these are equivalent
+            userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
+            userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")             
+        """
+        if name is not None:
+            return self.setResultsName(name)
+        else:
+            return self.copy()
+
+    def suppress( self ):
+        """
+        Suppresses the output of this C{ParserElement}; useful to keep punctuation from
+        cluttering up returned output.
+        """
+        return Suppress( self )
+
+    def leaveWhitespace( self ):
+        """
+        Disables the skipping of whitespace before matching the characters in the
+        C{ParserElement}'s defined pattern.  This is normally only used internally by
+        the pyparsing module, but may be needed in some whitespace-sensitive grammars.
+        """
+        self.skipWhitespace = False
+        return self
+
+    def setWhitespaceChars( self, chars ):
+        """
+        Overrides the default whitespace chars
+        """
+        self.skipWhitespace = True
+        self.whiteChars = chars
+        self.copyDefaultWhiteChars = False
+        return self
+
+    def parseWithTabs( self ):
+        """
+        Overrides default behavior to expand C{<TAB>}s to spaces before parsing the input string.
+        Must be called before C{parseString} when the input grammar contains elements that
+        match C{<TAB>} characters.
+        """
+        self.keepTabs = True
+        return self
+
+    def ignore( self, other ):
+        """
+        Define expression to be ignored (e.g., comments) while doing pattern
+        matching; may be called repeatedly, to define multiple comment or other
+        ignorable patterns.
+        
+        Example::
+            patt = OneOrMore(Word(alphas))
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj']
+            
+            patt.ignore(cStyleComment)
+            patt.parseString('ablaj /* comment */ lskjd') # -> ['ablaj', 'lskjd']
+        """
+        if isinstance(other, basestring):
+            other = Suppress(other)
+
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                self.ignoreExprs.append(other)
+        else:
+            self.ignoreExprs.append( Suppress( other.copy() ) )
+        return self
+
+    def setDebugActions( self, startAction, successAction, exceptionAction ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        """
+        self.debugActions = (startAction or _defaultStartDebugAction,
+                             successAction or _defaultSuccessDebugAction,
+                             exceptionAction or _defaultExceptionDebugAction)
+        self.debug = True
+        return self
+
+    def setDebug( self, flag=True ):
+        """
+        Enable display of debugging messages while doing pattern matching.
+        Set C{flag} to True to enable, False to disable.
+
+        Example::
+            wd = Word(alphas).setName("alphaword")
+            integer = Word(nums).setName("numword")
+            term = wd | integer
+            
+            # turn on debugging for wd
+            wd.setDebug()
+
+            OneOrMore(term).parseString("abc 123 xyz 890")
+        
+        prints::
+            Match alphaword at loc 0(1,1)
+            Matched alphaword -> ['abc']
+            Match alphaword at loc 3(1,4)
+            Exception raised:Expected alphaword (at char 4), (line:1, col:5)
+            Match alphaword at loc 7(1,8)
+            Matched alphaword -> ['xyz']
+            Match alphaword at loc 11(1,12)
+            Exception raised:Expected alphaword (at char 12), (line:1, col:13)
+            Match alphaword at loc 15(1,16)
+            Exception raised:Expected alphaword (at char 15), (line:1, col:16)
+
+        The output shown is that produced by the default debug actions - custom debug actions can be
+        specified using L{setDebugActions}. Prior to attempting
+        to match the C{wd} expression, the debugging message C{"Match <exprname> at loc <n>(<line>,<col>)"}
+        is shown. Then if the parse succeeds, a C{"Matched"} message is shown, or an C{"Exception raised"}
+        message is shown. Also note the use of L{setName} to assign a human-readable name to the expression,
+        which makes debugging and exception messages easier to understand - for instance, the default
+        name created for the C{Word} expression without calling C{setName} is C{"W:(ABCD...)"}.
+        """
+        if flag:
+            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
+        else:
+            self.debug = False
+        return self
+
+    def __str__( self ):
+        return self.name
+
+    def __repr__( self ):
+        return _ustr(self)
+
+    def streamline( self ):
+        self.streamlined = True
+        self.strRepr = None
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        pass
+
+    def validate( self, validateTrace=[] ):
+        """
+        Check defined expressions for valid structure, check for infinite recursive definitions.
+        """
+        self.checkRecursion( [] )
+
+    def parseFile( self, file_or_filename, parseAll=False ):
+        """
+        Execute the parse expression on the given file or filename.
+        If a filename is specified (instead of a file object),
+        the entire file is opened, read, and closed before parsing.
+        """
+        try:
+            file_contents = file_or_filename.read()
+        except AttributeError:
+            with open(file_or_filename, "r") as f:
+                file_contents = f.read()
+        try:
+            return self.parseString(file_contents, parseAll)
+        except ParseBaseException as exc:
+            if ParserElement.verbose_stacktrace:
+                raise
+            else:
+                # catch and re-raise exception from here, clears out pyparsing internal stack trace
+                raise exc
+
+    def __eq__(self,other):
+        if isinstance(other, ParserElement):
+            return self is other or vars(self) == vars(other)
+        elif isinstance(other, basestring):
+            return self.matches(other)
+        else:
+            return super(ParserElement,self)==other
+
+    def __ne__(self,other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(id(self))
+
+    def __req__(self,other):
+        return self == other
+
+    def __rne__(self,other):
+        return not (self == other)
+
+    def matches(self, testString, parseAll=True):
+        """
+        Method for quick testing of a parser against a test string. Good for simple 
+        inline microtests of sub expressions while building up larger parser.
+           
+        Parameters:
+         - testString - to test against this expression for a match
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests
+            
+        Example::
+            expr = Word(nums)
+            assert expr.matches("100")
+        """
+        try:
+            self.parseString(_ustr(testString), parseAll=parseAll)
+            return True
+        except ParseBaseException:
+            return False
+                
+    def runTests(self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False):
+        """
+        Execute the parse expression on a series of test strings, showing each
+        test, the parsed results or where the parse failed. Quick and easy way to
+        run a parse expression against a list of sample strings.
+           
+        Parameters:
+         - tests - a list of separate test strings, or a multiline string of test strings
+         - parseAll - (default=C{True}) - flag to pass to C{L{parseString}} when running tests           
+         - comment - (default=C{'#'}) - expression for indicating embedded comments in the test 
+              string; pass None to disable comment filtering
+         - fullDump - (default=C{True}) - dump results as list followed by results names in nested outline;
+              if False, only dump nested list
+         - printResults - (default=C{True}) prints test output to stdout
+         - failureTests - (default=C{False}) indicates if these tests are expected to fail parsing
+
+        Returns: a (success, results) tuple, where success indicates that all tests succeeded
+        (or failed if C{failureTests} is True), and the results contain a list of lines of each 
+        test's output
+        
+        Example::
+            number_expr = pyparsing_common.number.copy()
+
+            result = number_expr.runTests('''
+                # unsigned integer
+                100
+                # negative integer
+                -100
+                # float with scientific notation
+                6.02e23
+                # integer with scientific notation
+                1e-12
+                ''')
+            print("Success" if result[0] else "Failed!")
+
+            result = number_expr.runTests('''
+                # stray character
+                100Z
+                # missing leading digit before '.'
+                -.100
+                # too many '.'
+                3.14.159
+                ''', failureTests=True)
+            print("Success" if result[0] else "Failed!")
+        prints::
+            # unsigned integer
+            100
+            [100]
+
+            # negative integer
+            -100
+            [-100]
+
+            # float with scientific notation
+            6.02e23
+            [6.02e+23]
+
+            # integer with scientific notation
+            1e-12
+            [1e-12]
+
+            Success
+            
+            # stray character
+            100Z
+               ^
+            FAIL: Expected end of text (at char 3), (line:1, col:4)
+
+            # missing leading digit before '.'
+            -.100
+            ^
+            FAIL: Expected {real number with scientific notation | real number | signed integer} (at char 0), (line:1, col:1)
+
+            # too many '.'
+            3.14.159
+                ^
+            FAIL: Expected end of text (at char 4), (line:1, col:5)
+
+            Success
+
+        Each test string must be on a single line. If you want to test a string that spans multiple
+        lines, create a test like this::
+
+            expr.runTest(r"this is a test\\n of strings that spans \\n 3 lines")
+        
+        (Note that this is a raw string literal, you must include the leading 'r'.)
+        """
+        if isinstance(tests, basestring):
+            tests = list(map(str.strip, tests.rstrip().splitlines()))
+        if isinstance(comment, basestring):
+            comment = Literal(comment)
+        allResults = []
+        comments = []
+        success = True
+        for t in tests:
+            if comment is not None and comment.matches(t, False) or comments and not t:
+                comments.append(t)
+                continue
+            if not t:
+                continue
+            out = ['\n'.join(comments), t]
+            comments = []
+            try:
+                t = t.replace(r'\n','\n')
+                result = self.parseString(t, parseAll=parseAll)
+                out.append(result.dump(full=fullDump))
+                success = success and not failureTests
+            except ParseBaseException as pe:
+                fatal = "(FATAL)" if isinstance(pe, ParseFatalException) else ""
+                if '\n' in t:
+                    out.append(line(pe.loc, t))
+                    out.append(' '*(col(pe.loc,t)-1) + '^' + fatal)
+                else:
+                    out.append(' '*pe.loc + '^' + fatal)
+                out.append("FAIL: " + str(pe))
+                success = success and failureTests
+                result = pe
+            except Exception as exc:
+                out.append("FAIL-EXCEPTION: " + str(exc))
+                success = success and failureTests
+                result = exc
+
+            if printResults:
+                if fullDump:
+                    out.append('')
+                print('\n'.join(out))
+
+            allResults.append((t, result))
+        
+        return success, allResults
+
+        
+class Token(ParserElement):
+    """
+    Abstract C{ParserElement} subclass, for defining atomic matching patterns.
+    """
+    def __init__( self ):
+        super(Token,self).__init__( savelist=False )
+
+
+class Empty(Token):
+    """
+    An empty token, will always match.
+    """
+    def __init__( self ):
+        super(Empty,self).__init__()
+        self.name = "Empty"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+
+class NoMatch(Token):
+    """
+    A token that will never match.
+    """
+    def __init__( self ):
+        super(NoMatch,self).__init__()
+        self.name = "NoMatch"
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.errmsg = "Unmatchable token"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Literal(Token):
+    """
+    Token to exactly match a specified string.
+    
+    Example::
+        Literal('blah').parseString('blah')  # -> ['blah']
+        Literal('blah').parseString('blahfooblah')  # -> ['blah']
+        Literal('blah').parseString('bla')  # -> Exception: Expected "blah"
+    
+    For case-insensitive matching, use L{CaselessLiteral}.
+    
+    For keyword matching (force word break before and after the matched string),
+    use L{Keyword} or L{CaselessKeyword}.
+    """
+    def __init__( self, matchString ):
+        super(Literal,self).__init__()
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Literal; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+            self.__class__ = Empty
+        self.name = '"%s"' % _ustr(self.match)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+
+    # Performance tuning: this routine gets called a *lot*
+    # if this is a single character match string  and the first character matches,
+    # short-circuit as quickly as possible, and avoid calling startswith
+    #~ @profile
+    def parseImpl( self, instring, loc, doActions=True ):
+        if (instring[loc] == self.firstMatchChar and
+            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+_L = Literal
+ParserElement._literalStringClass = Literal
+
+class Keyword(Token):
+    """
+    Token to exactly match a specified string as a keyword, that is, it must be
+    immediately followed by a non-keyword character.  Compare with C{L{Literal}}:
+     - C{Literal("if")} will match the leading C{'if'} in C{'ifAndOnlyIf'}.
+     - C{Keyword("if")} will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
+    Accepts two optional constructor arguments in addition to the keyword string:
+     - C{identChars} is a string of characters that would be valid identifier characters,
+          defaulting to all alphanumerics + "_" and "$"
+     - C{caseless} allows case-insensitive matching, default is C{False}.
+       
+    Example::
+        Keyword("start").parseString("start")  # -> ['start']
+        Keyword("start").parseString("starting")  # -> Exception
+
+    For case-insensitive matching, use L{CaselessKeyword}.
+    """
+    DEFAULT_KEYWORD_CHARS = alphanums+"_$"
+
+    def __init__( self, matchString, identChars=None, caseless=False ):
+        super(Keyword,self).__init__()
+        if identChars is None:
+            identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        self.match = matchString
+        self.matchLen = len(matchString)
+        try:
+            self.firstMatchChar = matchString[0]
+        except IndexError:
+            warnings.warn("null string passed to Keyword; use Empty() instead",
+                            SyntaxWarning, stacklevel=2)
+        self.name = '"%s"' % self.match
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = False
+        self.mayIndexError = False
+        self.caseless = caseless
+        if caseless:
+            self.caselessmatch = matchString.upper()
+            identChars = identChars.upper()
+        self.identChars = set(identChars)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.caseless:
+            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
+                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        else:
+            if (instring[loc] == self.firstMatchChar and
+                (self.matchLen==1 or instring.startswith(self.match,loc)) and
+                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
+                (loc == 0 or instring[loc-1] not in self.identChars) ):
+                return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+    def copy(self):
+        c = super(Keyword,self).copy()
+        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
+        return c
+
+    @staticmethod
+    def setDefaultKeywordChars( chars ):
+        """Overrides the default Keyword chars
+        """
+        Keyword.DEFAULT_KEYWORD_CHARS = chars
+
+class CaselessLiteral(Literal):
+    """
+    Token to match a specified string, ignoring case of letters.
+    Note: the matched results will always be in the case of the given
+    match string, NOT the case of the input text.
+
+    Example::
+        OneOrMore(CaselessLiteral("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessKeyword}.)
+    """
+    def __init__( self, matchString ):
+        super(CaselessLiteral,self).__init__( matchString.upper() )
+        # Preserve the defining literal.
+        self.returnString = matchString
+        self.name = "'%s'" % self.returnString
+        self.errmsg = "Expected " + self.name
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[ loc:loc+self.matchLen ].upper() == self.match:
+            return loc+self.matchLen, self.returnString
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CaselessKeyword(Keyword):
+    """
+    Caseless version of L{Keyword}.
+
+    Example::
+        OneOrMore(CaselessKeyword("CMD")).parseString("cmd CMD Cmd10") # -> ['CMD', 'CMD']
+        
+    (Contrast with example for L{CaselessLiteral}.)
+    """
+    def __init__( self, matchString, identChars=None ):
+        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
+             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
+            return loc+self.matchLen, self.match
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class CloseMatch(Token):
+    """
+    A variation on L{Literal} which matches "close" matches, that is, 
+    strings with at most 'n' mismatching characters. C{CloseMatch} takes parameters:
+     - C{match_string} - string to be matched
+     - C{maxMismatches} - (C{default=1}) maximum number of mismatches allowed to count as a match
+    
+    The results from a successful parse will contain the matched text from the input string and the following named results:
+     - C{mismatches} - a list of the positions within the match_string where mismatches were found
+     - C{original} - the original match_string used to compare against the input string
+    
+    If C{mismatches} is an empty list, then the match was an exact match.
+    
+    Example::
+        patt = CloseMatch("ATCATCGAATGGA")
+        patt.parseString("ATCATCGAAXGGA") # -> (['ATCATCGAAXGGA'], {'mismatches': [[9]], 'original': ['ATCATCGAATGGA']})
+        patt.parseString("ATCAXCGAAXGGA") # -> Exception: Expected 'ATCATCGAATGGA' (with up to 1 mismatches) (at char 0), (line:1, col:1)
+
+        # exact match
+        patt.parseString("ATCATCGAATGGA") # -> (['ATCATCGAATGGA'], {'mismatches': [[]], 'original': ['ATCATCGAATGGA']})
+
+        # close match allowing up to 2 mismatches
+        patt = CloseMatch("ATCATCGAATGGA", maxMismatches=2)
+        patt.parseString("ATCAXCGAAXGGA") # -> (['ATCAXCGAAXGGA'], {'mismatches': [[4, 9]], 'original': ['ATCATCGAATGGA']})
+    """
+    def __init__(self, match_string, maxMismatches=1):
+        super(CloseMatch,self).__init__()
+        self.name = match_string
+        self.match_string = match_string
+        self.maxMismatches = maxMismatches
+        self.errmsg = "Expected %r (with up to %d mismatches)" % (self.match_string, self.maxMismatches)
+        self.mayIndexError = False
+        self.mayReturnEmpty = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        start = loc
+        instrlen = len(instring)
+        maxloc = start + len(self.match_string)
+
+        if maxloc <= instrlen:
+            match_string = self.match_string
+            match_stringloc = 0
+            mismatches = []
+            maxMismatches = self.maxMismatches
+
+            for match_stringloc,s_m in enumerate(zip(instring[loc:maxloc], self.match_string)):
+                src,mat = s_m
+                if src != mat:
+                    mismatches.append(match_stringloc)
+                    if len(mismatches) > maxMismatches:
+                        break
+            else:
+                loc = match_stringloc + 1
+                results = ParseResults([instring[start:loc]])
+                results['original'] = self.match_string
+                results['mismatches'] = mismatches
+                return loc, results
+
+        raise ParseException(instring, loc, self.errmsg, self)
+
+
+class Word(Token):
+    """
+    Token for matching words composed of allowed character sets.
+    Defined with string containing all allowed initial characters,
+    an optional string containing allowed body characters (if omitted,
+    defaults to the initial character set), and an optional minimum,
+    maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction. An optional
+    C{excludeChars} parameter can list characters that might be found in 
+    the input C{bodyChars} string; useful to define a word of all printables
+    except for one or two characters, for instance.
+    
+    L{srange} is useful for defining custom character set strings for defining 
+    C{Word} expressions, using range notation from regular expression character sets.
+    
+    A common mistake is to use C{Word} to match a specific literal string, as in 
+    C{Word("Address")}. Remember that C{Word} uses the string argument to define
+    I{sets} of matchable characters. This expression would match "Add", "AAA",
+    "dAred", or any other word made up of the characters 'A', 'd', 'r', 'e', and 's'.
+    To match an exact literal string, use L{Literal} or L{Keyword}.
+
+    pyparsing includes helper strings for building Words:
+     - L{alphas}
+     - L{nums}
+     - L{alphanums}
+     - L{hexnums}
+     - L{alphas8bit} (alphabetic characters in ASCII range 128-255 - accented, tilded, umlauted, etc.)
+     - L{punc8bit} (non-alphabetic characters in ASCII range 128-255 - currency, symbols, superscripts, diacriticals, etc.)
+     - L{printables} (any non-whitespace character)
+
+    Example::
+        # a word composed of digits
+        integer = Word(nums) # equivalent to Word("0123456789") or Word(srange("0-9"))
+        
+        # a word with a leading capital, and zero or more lowercase
+        capital_word = Word(alphas.upper(), alphas.lower())
+
+        # hostnames are alphanumeric, with leading alpha, and '-'
+        hostname = Word(alphas, alphanums+'-')
+        
+        # roman numeral (not a strict parser, accepts invalid mix of characters)
+        roman = Word("IVXLCDM")
+        
+        # any string of non-whitespace characters, except for ','
+        csv_value = Word(printables, excludeChars=",")
+    """
+    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
+        super(Word,self).__init__()
+        if excludeChars:
+            initChars = ''.join(c for c in initChars if c not in excludeChars)
+            if bodyChars:
+                bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
+        self.initCharsOrig = initChars
+        self.initChars = set(initChars)
+        if bodyChars :
+            self.bodyCharsOrig = bodyChars
+            self.bodyChars = set(bodyChars)
+        else:
+            self.bodyCharsOrig = initChars
+            self.bodyChars = set(initChars)
+
+        self.maxSpecified = max > 0
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.asKeyword = asKeyword
+
+        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
+            if self.bodyCharsOrig == self.initCharsOrig:
+                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
+            elif len(self.initCharsOrig) == 1:
+                self.reString = "%s[%s]*" % \
+                                      (re.escape(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            else:
+                self.reString = "[%s][%s]*" % \
+                                      (_escapeRegexRangeChars(self.initCharsOrig),
+                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
+            if self.asKeyword:
+                self.reString = r"\b"+self.reString+r"\b"
+            try:
+                self.re = re.compile( self.reString )
+            except Exception:
+                self.re = None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.re:
+            result = self.re.match(instring,loc)
+            if not result:
+                raise ParseException(instring, loc, self.errmsg, self)
+
+            loc = result.end()
+            return loc, result.group()
+
+        if not(instring[ loc ] in self.initChars):
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        instrlen = len(instring)
+        bodychars = self.bodyChars
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, instrlen )
+        while loc < maxloc and instring[loc] in bodychars:
+            loc += 1
+
+        throwException = False
+        if loc - start < self.minLen:
+            throwException = True
+        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
+            throwException = True
+        if self.asKeyword:
+            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
+                throwException = True
+
+        if throwException:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(Word,self).__str__()
+        except Exception:
+            pass
+
+
+        if self.strRepr is None:
+
+            def charsAsStr(s):
+                if len(s)>4:
+                    return s[:4]+"..."
+                else:
+                    return s
+
+            if ( self.initCharsOrig != self.bodyCharsOrig ):
+                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
+            else:
+                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
+
+        return self.strRepr
+
+
+class Regex(Token):
+    r"""
+    Token for matching strings that match a given regular expression.
+    Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
+    If the given regex contains named groups (defined using C{(?P<name>...)}), these will be preserved as 
+    named parse results.
+
+    Example::
+        realnum = Regex(r"[+-]?\d+\.\d*")
+        date = Regex(r'(?P<year>\d{4})-(?P<month>\d\d?)-(?P<day>\d\d?)')
+        # ref: http://stackoverflow.com/questions/267399/how-do-you-match-only-valid-roman-numerals-with-a-regular-expression
+        roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
+    """
+    compiledREtype = type(re.compile("[A-Z]"))
+    def __init__( self, pattern, flags=0):
+        """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
+        super(Regex,self).__init__()
+
+        if isinstance(pattern, basestring):
+            if not pattern:
+                warnings.warn("null string passed to Regex; use Empty() instead",
+                        SyntaxWarning, stacklevel=2)
+
+            self.pattern = pattern
+            self.flags = flags
+
+            try:
+                self.re = re.compile(self.pattern, self.flags)
+                self.reString = self.pattern
+            except sre_constants.error:
+                warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
+                    SyntaxWarning, stacklevel=2)
+                raise
+
+        elif isinstance(pattern, Regex.compiledREtype):
+            self.re = pattern
+            self.pattern = \
+            self.reString = str(pattern)
+            self.flags = flags
+            
+        else:
+            raise ValueError("Regex may only be constructed with a string or a compiled RE object")
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = self.re.match(instring,loc)
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        d = result.groupdict()
+        ret = ParseResults(result.group())
+        if d:
+            for k in d:
+                ret[k] = d[k]
+        return loc,ret
+
+    def __str__( self ):
+        try:
+            return super(Regex,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "Re:(%s)" % repr(self.pattern)
+
+        return self.strRepr
+
+
+class QuotedString(Token):
+    r"""
+    Token for matching strings that are delimited by quoting characters.
+    
+    Defined with the following parameters:
+        - quoteChar - string of one or more characters defining the quote delimiting string
+        - escChar - character to escape quotes, typically backslash (default=C{None})
+        - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=C{None})
+        - multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
+        - unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
+        - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
+        - convertWhitespaceEscapes - convert escaped whitespace (C{'\t'}, C{'\n'}, etc.) to actual whitespace (default=C{True})
+
+    Example::
+        qs = QuotedString('"')
+        print(qs.searchString('lsjdf "This is the quote" sldjf'))
+        complex_qs = QuotedString('{{', endQuoteChar='}}')
+        print(complex_qs.searchString('lsjdf {{This is the "quote"}} sldjf'))
+        sql_qs = QuotedString('"', escQuote='""')
+        print(sql_qs.searchString('lsjdf "This is the quote with ""embedded"" quotes" sldjf'))
+    prints::
+        [['This is the quote']]
+        [['This is the "quote"']]
+        [['This is the quote with "embedded" quotes']]
+    """
+    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None, convertWhitespaceEscapes=True):
+        super(QuotedString,self).__init__()
+
+        # remove white space from quote chars - wont work anyway
+        quoteChar = quoteChar.strip()
+        if not quoteChar:
+            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+            raise SyntaxError()
+
+        if endQuoteChar is None:
+            endQuoteChar = quoteChar
+        else:
+            endQuoteChar = endQuoteChar.strip()
+            if not endQuoteChar:
+                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
+                raise SyntaxError()
+
+        self.quoteChar = quoteChar
+        self.quoteCharLen = len(quoteChar)
+        self.firstQuoteChar = quoteChar[0]
+        self.endQuoteChar = endQuoteChar
+        self.endQuoteCharLen = len(endQuoteChar)
+        self.escChar = escChar
+        self.escQuote = escQuote
+        self.unquoteResults = unquoteResults
+        self.convertWhitespaceEscapes = convertWhitespaceEscapes
+
+        if multiline:
+            self.flags = re.MULTILINE | re.DOTALL
+            self.pattern = r'%s(?:[^%s%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        else:
+            self.flags = 0
+            self.pattern = r'%s(?:[^%s\n\r%s]' % \
+                ( re.escape(self.quoteChar),
+                  _escapeRegexRangeChars(self.endQuoteChar[0]),
+                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
+        if len(self.endQuoteChar) > 1:
+            self.pattern += (
+                '|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
+                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
+                                    for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
+                )
+        if escQuote:
+            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
+        if escChar:
+            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
+            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
+        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
+
+        try:
+            self.re = re.compile(self.pattern, self.flags)
+            self.reString = self.pattern
+        except sre_constants.error:
+            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
+                SyntaxWarning, stacklevel=2)
+            raise
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayIndexError = False
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
+        if not result:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        loc = result.end()
+        ret = result.group()
+
+        if self.unquoteResults:
+
+            # strip off quotes
+            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
+
+            if isinstance(ret,basestring):
+                # replace escaped whitespace
+                if '\\' in ret and self.convertWhitespaceEscapes:
+                    ws_map = {
+                        r'\t' : '\t',
+                        r'\n' : '\n',
+                        r'\f' : '\f',
+                        r'\r' : '\r',
+                    }
+                    for wslit,wschar in ws_map.items():
+                        ret = ret.replace(wslit, wschar)
+
+                # replace escaped characters
+                if self.escChar:
+                    ret = re.sub(self.escCharReplacePattern, r"\g<1>", ret)
+
+                # replace escaped quotes
+                if self.escQuote:
+                    ret = ret.replace(self.escQuote, self.endQuoteChar)
+
+        return loc, ret
+
+    def __str__( self ):
+        try:
+            return super(QuotedString,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
+
+        return self.strRepr
+
+
+class CharsNotIn(Token):
+    """
+    Token for matching words composed of characters I{not} in a given set (will
+    include whitespace in matched characters if not listed in the provided exclusion set - see example).
+    Defined with string containing all disallowed characters, and an optional
+    minimum, maximum, and/or exact length.  The default value for C{min} is 1 (a
+    minimum value < 1 is not valid); the default values for C{max} and C{exact}
+    are 0, meaning no maximum or exact length restriction.
+
+    Example::
+        # define a comma-separated-value as anything that is not a ','
+        csv_value = CharsNotIn(',')
+        print(delimitedList(csv_value).parseString("dkls,lsdkjf,s12 34,@!#,213"))
+    prints::
+        ['dkls', 'lsdkjf', 's12 34', '@!#', '213']
+    """
+    def __init__( self, notChars, min=1, max=0, exact=0 ):
+        super(CharsNotIn,self).__init__()
+        self.skipWhitespace = False
+        self.notChars = notChars
+
+        if min < 1:
+            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+        self.name = _ustr(self)
+        self.errmsg = "Expected " + self.name
+        self.mayReturnEmpty = ( self.minLen == 0 )
+        self.mayIndexError = False
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if instring[loc] in self.notChars:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        start = loc
+        loc += 1
+        notchars = self.notChars
+        maxlen = min( start+self.maxLen, len(instring) )
+        while loc < maxlen and \
+              (instring[loc] not in notchars):
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+    def __str__( self ):
+        try:
+            return super(CharsNotIn, self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            if len(self.notChars) > 4:
+                self.strRepr = "!W:(%s...)" % self.notChars[:4]
+            else:
+                self.strRepr = "!W:(%s)" % self.notChars
+
+        return self.strRepr
+
+class White(Token):
+    """
+    Special matching class for matching whitespace.  Normally, whitespace is ignored
+    by pyparsing grammars.  This class is included when some whitespace structures
+    are significant.  Define with a string containing the whitespace characters to be
+    matched; default is C{" \\t\\r\\n"}.  Also takes optional C{min}, C{max}, and C{exact} arguments,
+    as defined for the C{L{Word}} class.
+    """
+    whiteStrs = {
+        " " : "<SPC>",
+        "\t": "<TAB>",
+        "\n": "<LF>",
+        "\r": "<CR>",
+        "\f": "<FF>",
+        }
+    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
+        super(White,self).__init__()
+        self.matchWhite = ws
+        self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
+        #~ self.leaveWhitespace()
+        self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
+        self.mayReturnEmpty = True
+        self.errmsg = "Expected " + self.name
+
+        self.minLen = min
+
+        if max > 0:
+            self.maxLen = max
+        else:
+            self.maxLen = _MAX_INT
+
+        if exact > 0:
+            self.maxLen = exact
+            self.minLen = exact
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if not(instring[ loc ] in self.matchWhite):
+            raise ParseException(instring, loc, self.errmsg, self)
+        start = loc
+        loc += 1
+        maxloc = start + self.maxLen
+        maxloc = min( maxloc, len(instring) )
+        while loc < maxloc and instring[loc] in self.matchWhite:
+            loc += 1
+
+        if loc - start < self.minLen:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        return loc, instring[start:loc]
+
+
+class _PositionToken(Token):
+    def __init__( self ):
+        super(_PositionToken,self).__init__()
+        self.name=self.__class__.__name__
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+
+class GoToColumn(_PositionToken):
+    """
+    Token to advance to a specific column of input text; useful for tabular report scraping.
+    """
+    def __init__( self, colno ):
+        super(GoToColumn,self).__init__()
+        self.col = colno
+
+    def preParse( self, instring, loc ):
+        if col(loc,instring) != self.col:
+            instrlen = len(instring)
+            if self.ignoreExprs:
+                loc = self._skipIgnorables( instring, loc )
+            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
+                loc += 1
+        return loc
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        thiscol = col( loc, instring )
+        if thiscol > self.col:
+            raise ParseException( instring, loc, "Text not in expected column", self )
+        newloc = loc + self.col - thiscol
+        ret = instring[ loc: newloc ]
+        return newloc, ret
+
+
+class LineStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of a line within the parse string
+    
+    Example::
+    
+        test = '''\
+        AAA this line
+        AAA and this line
+          AAA but not this one
+        B AAA and definitely not this one
+        '''
+
+        for t in (LineStart() + 'AAA' + restOfLine).searchString(test):
+            print(t)
+    
+    Prints::
+        ['AAA', ' this line']
+        ['AAA', ' and this line']    
+
+    """
+    def __init__( self ):
+        super(LineStart,self).__init__()
+        self.errmsg = "Expected start of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if col(loc, instring) == 1:
+            return loc, []
+        raise ParseException(instring, loc, self.errmsg, self)
+
+class LineEnd(_PositionToken):
+    """
+    Matches if current position is at the end of a line within the parse string
+    """
+    def __init__( self ):
+        super(LineEnd,self).__init__()
+        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
+        self.errmsg = "Expected end of line"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc<len(instring):
+            if instring[loc] == "\n":
+                return loc+1, "\n"
+            else:
+                raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class StringStart(_PositionToken):
+    """
+    Matches if current position is at the beginning of the parse string
+    """
+    def __init__( self ):
+        super(StringStart,self).__init__()
+        self.errmsg = "Expected start of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc != 0:
+            # see if entire string up to here is just whitespace and ignoreables
+            if loc != self.preParse( instring, 0 ):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class StringEnd(_PositionToken):
+    """
+    Matches if current position is at the end of the parse string
+    """
+    def __init__( self ):
+        super(StringEnd,self).__init__()
+        self.errmsg = "Expected end of text"
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if loc < len(instring):
+            raise ParseException(instring, loc, self.errmsg, self)
+        elif loc == len(instring):
+            return loc+1, []
+        elif loc > len(instring):
+            return loc, []
+        else:
+            raise ParseException(instring, loc, self.errmsg, self)
+
+class WordStart(_PositionToken):
+    """
+    Matches if the current position is at the beginning of a Word, and
+    is not preceded by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
+    the string being parsed, or at the beginning of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordStart,self).__init__()
+        self.wordChars = set(wordChars)
+        self.errmsg = "Not at the start of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        if loc != 0:
+            if (instring[loc-1] in self.wordChars or
+                instring[loc] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+class WordEnd(_PositionToken):
+    """
+    Matches if the current position is at the end of a Word, and
+    is not followed by any character in a given set of C{wordChars}
+    (default=C{printables}). To emulate the C{\b} behavior of regular expressions,
+    use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
+    the string being parsed, or at the end of a line.
+    """
+    def __init__(self, wordChars = printables):
+        super(WordEnd,self).__init__()
+        self.wordChars = set(wordChars)
+        self.skipWhitespace = False
+        self.errmsg = "Not at the end of a word"
+
+    def parseImpl(self, instring, loc, doActions=True ):
+        instrlen = len(instring)
+        if instrlen>0 and loc<instrlen:
+            if (instring[loc] in self.wordChars or
+                instring[loc-1] not in self.wordChars):
+                raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+
+class ParseExpression(ParserElement):
+    """
+    Abstract subclass of ParserElement, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(ParseExpression,self).__init__(savelist)
+        if isinstance( exprs, _generatorType ):
+            exprs = list(exprs)
+
+        if isinstance( exprs, basestring ):
+            self.exprs = [ ParserElement._literalStringClass( exprs ) ]
+        elif isinstance( exprs, Iterable ):
+            exprs = list(exprs)
+            # if sequence of strings provided, wrap with Literal
+            if all(isinstance(expr, basestring) for expr in exprs):
+                exprs = map(ParserElement._literalStringClass, exprs)
+            self.exprs = list(exprs)
+        else:
+            try:
+                self.exprs = list( exprs )
+            except TypeError:
+                self.exprs = [ exprs ]
+        self.callPreparse = False
+
+    def __getitem__( self, i ):
+        return self.exprs[i]
+
+    def append( self, other ):
+        self.exprs.append( other )
+        self.strRepr = None
+        return self
+
+    def leaveWhitespace( self ):
+        """Extends C{leaveWhitespace} defined in base class, and also invokes C{leaveWhitespace} on
+           all contained expressions."""
+        self.skipWhitespace = False
+        self.exprs = [ e.copy() for e in self.exprs ]
+        for e in self.exprs:
+            e.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseExpression, self).ignore( other )
+                for e in self.exprs:
+                    e.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseExpression, self).ignore( other )
+            for e in self.exprs:
+                e.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def __str__( self ):
+        try:
+            return super(ParseExpression,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )
+        return self.strRepr
+
+    def streamline( self ):
+        super(ParseExpression,self).streamline()
+
+        for e in self.exprs:
+            e.streamline()
+
+        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )
+        # but only if there are no parse actions or resultsNames on the nested And's
+        # (likewise for Or's and MatchFirst's)
+        if ( len(self.exprs) == 2 ):
+            other = self.exprs[0]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = other.exprs[:] + [ self.exprs[1] ]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+            other = self.exprs[-1]
+            if ( isinstance( other, self.__class__ ) and
+                  not(other.parseAction) and
+                  other.resultsName is None and
+                  not other.debug ):
+                self.exprs = self.exprs[:-1] + other.exprs[:]
+                self.strRepr = None
+                self.mayReturnEmpty |= other.mayReturnEmpty
+                self.mayIndexError  |= other.mayIndexError
+
+        self.errmsg = "Expected " + _ustr(self)
+        
+        return self
+
+    def setResultsName( self, name, listAllMatches=False ):
+        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)
+        return ret
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        for e in self.exprs:
+            e.validate(tmp)
+        self.checkRecursion( [] )
+        
+    def copy(self):
+        ret = super(ParseExpression,self).copy()
+        ret.exprs = [e.copy() for e in self.exprs]
+        return ret
+
+class And(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found in the given order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'+'} operator.
+    May also be constructed using the C{'-'} operator, which will suppress backtracking.
+
+    Example::
+        integer = Word(nums)
+        name_expr = OneOrMore(Word(alphas))
+
+        expr = And([integer("id"),name_expr("name"),integer("age")])
+        # more easily written as:
+        expr = integer("id") + name_expr("name") + integer("age")
+    """
+
+    class _ErrorStop(Empty):
+        def __init__(self, *args, **kwargs):
+            super(And._ErrorStop,self).__init__(*args, **kwargs)
+            self.name = '-'
+            self.leaveWhitespace()
+
+    def __init__( self, exprs, savelist = True ):
+        super(And,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.setWhitespaceChars( self.exprs[0].whiteChars )
+        self.skipWhitespace = self.exprs[0].skipWhitespace
+        self.callPreparse = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        # pass False as last arg to _parse for first element, since we already
+        # pre-parsed the string as part of our And pre-parsing
+        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )
+        errorStop = False
+        for e in self.exprs[1:]:
+            if isinstance(e, And._ErrorStop):
+                errorStop = True
+                continue
+            if errorStop:
+                try:
+                    loc, exprtokens = e._parse( instring, loc, doActions )
+                except ParseSyntaxException:
+                    raise
+                except ParseBaseException as pe:
+                    pe.__traceback__ = None
+                    raise ParseSyntaxException._from_exception(pe)
+                except IndexError:
+                    raise ParseSyntaxException(instring, len(instring), self.errmsg, self)
+            else:
+                loc, exprtokens = e._parse( instring, loc, doActions )
+            if exprtokens or exprtokens.haskeys():
+                resultlist += exprtokens
+        return loc, resultlist
+
+    def __iadd__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #And( [ self, other ] )
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+            if not e.mayReturnEmpty:
+                break
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+
+class Or(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the expression that matches the longest string will be used.
+    May be constructed using the C{'^'} operator.
+
+    Example::
+        # construct Or using '^' operator
+        
+        number = Word(nums) ^ Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789"))
+    prints::
+        [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(Or,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        matches = []
+        for e in self.exprs:
+            try:
+                loc2 = e.tryParse( instring, loc )
+            except ParseException as err:
+                err.__traceback__ = None
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+            else:
+                # save match among all matches, to retry longest to shortest
+                matches.append((loc2, e))
+
+        if matches:
+            matches.sort(key=lambda x: -x[0])
+            for _,e in matches:
+                try:
+                    return e._parse( instring, loc, doActions )
+                except ParseException as err:
+                    err.__traceback__ = None
+                    if err.loc > maxExcLoc:
+                        maxException = err
+                        maxExcLoc = err.loc
+
+        if maxException is not None:
+            maxException.msg = self.errmsg
+            raise maxException
+        else:
+            raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+
+    def __ixor__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #Or( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class MatchFirst(ParseExpression):
+    """
+    Requires that at least one C{ParseExpression} is found.
+    If two expressions match, the first one listed is the one that will match.
+    May be constructed using the C{'|'} operator.
+
+    Example::
+        # construct MatchFirst using '|' operator
+        
+        # watch the order of expressions to match
+        number = Word(nums) | Combine(Word(nums) + '.' + Word(nums))
+        print(number.searchString("123 3.1416 789")) #  Fail! -> [['123'], ['3'], ['1416'], ['789']]
+
+        # put more selective expression first
+        number = Combine(Word(nums) + '.' + Word(nums)) | Word(nums)
+        print(number.searchString("123 3.1416 789")) #  Better -> [['123'], ['3.1416'], ['789']]
+    """
+    def __init__( self, exprs, savelist = False ):
+        super(MatchFirst,self).__init__(exprs, savelist)
+        if self.exprs:
+            self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
+        else:
+            self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        maxExcLoc = -1
+        maxException = None
+        for e in self.exprs:
+            try:
+                ret = e._parse( instring, loc, doActions )
+                return ret
+            except ParseException as err:
+                if err.loc > maxExcLoc:
+                    maxException = err
+                    maxExcLoc = err.loc
+            except IndexError:
+                if len(instring) > maxExcLoc:
+                    maxException = ParseException(instring,len(instring),e.errmsg,self)
+                    maxExcLoc = len(instring)
+
+        # only got here if no expression matched, raise exception for match that made it the furthest
+        else:
+            if maxException is not None:
+                maxException.msg = self.errmsg
+                raise maxException
+            else:
+                raise ParseException(instring, loc, "no defined alternatives to match", self)
+
+    def __ior__(self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass( other )
+        return self.append( other ) #MatchFirst( [ self, other ] )
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class Each(ParseExpression):
+    """
+    Requires all given C{ParseExpression}s to be found, but in any order.
+    Expressions may be separated by whitespace.
+    May be constructed using the C{'&'} operator.
+
+    Example::
+        color = oneOf("RED ORANGE YELLOW GREEN BLUE PURPLE BLACK WHITE BROWN")
+        shape_type = oneOf("SQUARE CIRCLE TRIANGLE STAR HEXAGON OCTAGON")
+        integer = Word(nums)
+        shape_attr = "shape:" + shape_type("shape")
+        posn_attr = "posn:" + Group(integer("x") + ',' + integer("y"))("posn")
+        color_attr = "color:" + color("color")
+        size_attr = "size:" + integer("size")
+
+        # use Each (using operator '&') to accept attributes in any order 
+        # (shape and posn are required, color and size are optional)
+        shape_spec = shape_attr & posn_attr & Optional(color_attr) & Optional(size_attr)
+
+        shape_spec.runTests('''
+            shape: SQUARE color: BLACK posn: 100, 120
+            shape: CIRCLE size: 50 color: BLUE posn: 50,80
+            color:GREEN size:20 shape:TRIANGLE posn:20,40
+            '''
+            )
+    prints::
+        shape: SQUARE color: BLACK posn: 100, 120
+        ['shape:', 'SQUARE', 'color:', 'BLACK', 'posn:', ['100', ',', '120']]
+        - color: BLACK
+        - posn: ['100', ',', '120']
+          - x: 100
+          - y: 120
+        - shape: SQUARE
+
+
+        shape: CIRCLE size: 50 color: BLUE posn: 50,80
+        ['shape:', 'CIRCLE', 'size:', '50', 'color:', 'BLUE', 'posn:', ['50', ',', '80']]
+        - color: BLUE
+        - posn: ['50', ',', '80']
+          - x: 50
+          - y: 80
+        - shape: CIRCLE
+        - size: 50
+
+
+        color: GREEN size: 20 shape: TRIANGLE posn: 20,40
+        ['color:', 'GREEN', 'size:', '20', 'shape:', 'TRIANGLE', 'posn:', ['20', ',', '40']]
+        - color: GREEN
+        - posn: ['20', ',', '40']
+          - x: 20
+          - y: 40
+        - shape: TRIANGLE
+        - size: 20
+    """
+    def __init__( self, exprs, savelist = True ):
+        super(Each,self).__init__(exprs, savelist)
+        self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
+        self.skipWhitespace = True
+        self.initExprGroups = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.initExprGroups:
+            self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
+            opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
+            opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
+            self.optionals = opt1 + opt2
+            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
+            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
+            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
+            self.required += self.multirequired
+            self.initExprGroups = False
+        tmpLoc = loc
+        tmpReqd = self.required[:]
+        tmpOpt  = self.optionals[:]
+        matchOrder = []
+
+        keepMatching = True
+        while keepMatching:
+            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
+            failed = []
+            for e in tmpExprs:
+                try:
+                    tmpLoc = e.tryParse( instring, tmpLoc )
+                except ParseException:
+                    failed.append(e)
+                else:
+                    matchOrder.append(self.opt1map.get(id(e),e))
+                    if e in tmpReqd:
+                        tmpReqd.remove(e)
+                    elif e in tmpOpt:
+                        tmpOpt.remove(e)
+            if len(failed) == len(tmpExprs):
+                keepMatching = False
+
+        if tmpReqd:
+            missing = ", ".join(_ustr(e) for e in tmpReqd)
+            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
+
+        # add any unmatched Optionals, in case they have default values defined
+        matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
+
+        resultlist = []
+        for e in matchOrder:
+            loc,results = e._parse(instring,loc,doActions)
+            resultlist.append(results)
+
+        finalResults = sum(resultlist, ParseResults([]))
+        return loc, finalResults
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
+
+        return self.strRepr
+
+    def checkRecursion( self, parseElementList ):
+        subRecCheckList = parseElementList[:] + [ self ]
+        for e in self.exprs:
+            e.checkRecursion( subRecCheckList )
+
+
+class ParseElementEnhance(ParserElement):
+    """
+    Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(ParseElementEnhance,self).__init__(savelist)
+        if isinstance( expr, basestring ):
+            if issubclass(ParserElement._literalStringClass, Token):
+                expr = ParserElement._literalStringClass(expr)
+            else:
+                expr = ParserElement._literalStringClass(Literal(expr))
+        self.expr = expr
+        self.strRepr = None
+        if expr is not None:
+            self.mayIndexError = expr.mayIndexError
+            self.mayReturnEmpty = expr.mayReturnEmpty
+            self.setWhitespaceChars( expr.whiteChars )
+            self.skipWhitespace = expr.skipWhitespace
+            self.saveAsList = expr.saveAsList
+            self.callPreparse = expr.callPreparse
+            self.ignoreExprs.extend(expr.ignoreExprs)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr is not None:
+            return self.expr._parse( instring, loc, doActions, callPreParse=False )
+        else:
+            raise ParseException("",loc,self.errmsg,self)
+
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        self.expr = self.expr.copy()
+        if self.expr is not None:
+            self.expr.leaveWhitespace()
+        return self
+
+    def ignore( self, other ):
+        if isinstance( other, Suppress ):
+            if other not in self.ignoreExprs:
+                super( ParseElementEnhance, self).ignore( other )
+                if self.expr is not None:
+                    self.expr.ignore( self.ignoreExprs[-1] )
+        else:
+            super( ParseElementEnhance, self).ignore( other )
+            if self.expr is not None:
+                self.expr.ignore( self.ignoreExprs[-1] )
+        return self
+
+    def streamline( self ):
+        super(ParseElementEnhance,self).streamline()
+        if self.expr is not None:
+            self.expr.streamline()
+        return self
+
+    def checkRecursion( self, parseElementList ):
+        if self in parseElementList:
+            raise RecursiveGrammarException( parseElementList+[self] )
+        subRecCheckList = parseElementList[:] + [ self ]
+        if self.expr is not None:
+            self.expr.checkRecursion( subRecCheckList )
+
+    def validate( self, validateTrace=[] ):
+        tmp = validateTrace[:]+[self]
+        if self.expr is not None:
+            self.expr.validate(tmp)
+        self.checkRecursion( [] )
+
+    def __str__( self ):
+        try:
+            return super(ParseElementEnhance,self).__str__()
+        except Exception:
+            pass
+
+        if self.strRepr is None and self.expr is not None:
+            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
+        return self.strRepr
+
+
+class FollowedBy(ParseElementEnhance):
+    """
+    Lookahead matching of the given parse expression.  C{FollowedBy}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression matches at the current
+    position.  C{FollowedBy} always returns a null token list.
+
+    Example::
+        # use FollowedBy to match a label only if it is followed by a ':'
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        OneOrMore(attr_expr).parseString("shape: SQUARE color: BLACK posn: upper left").pprint()
+    prints::
+        [['shape', 'SQUARE'], ['color', 'BLACK'], ['posn', 'upper left']]
+    """
+    def __init__( self, expr ):
+        super(FollowedBy,self).__init__(expr)
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self.expr.tryParse( instring, loc )
+        return loc, []
+
+
+class NotAny(ParseElementEnhance):
+    """
+    Lookahead to disallow matching with the given parse expression.  C{NotAny}
+    does I{not} advance the parsing position within the input string, it only
+    verifies that the specified parse expression does I{not} match at the current
+    position.  Also, C{NotAny} does I{not} skip over leading whitespace. C{NotAny}
+    always returns a null token list.  May be constructed using the '~' operator.
+
+    Example::
+        
+    """
+    def __init__( self, expr ):
+        super(NotAny,self).__init__(expr)
+        #~ self.leaveWhitespace()
+        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
+        self.mayReturnEmpty = True
+        self.errmsg = "Found unwanted token, "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        if self.expr.canParseNext(instring, loc):
+            raise ParseException(instring, loc, self.errmsg, self)
+        return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "~{" + _ustr(self.expr) + "}"
+
+        return self.strRepr
+
+class _MultipleMatch(ParseElementEnhance):
+    def __init__( self, expr, stopOn=None):
+        super(_MultipleMatch, self).__init__(expr)
+        self.saveAsList = True
+        ender = stopOn
+        if isinstance(ender, basestring):
+            ender = ParserElement._literalStringClass(ender)
+        self.not_ender = ~ender if ender is not None else None
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        self_expr_parse = self.expr._parse
+        self_skip_ignorables = self._skipIgnorables
+        check_ender = self.not_ender is not None
+        if check_ender:
+            try_not_ender = self.not_ender.tryParse
+        
+        # must be at least one (but first see if we are the stopOn sentinel;
+        # if so, fail)
+        if check_ender:
+            try_not_ender(instring, loc)
+        loc, tokens = self_expr_parse( instring, loc, doActions, callPreParse=False )
+        try:
+            hasIgnoreExprs = (not not self.ignoreExprs)
+            while 1:
+                if check_ender:
+                    try_not_ender(instring, loc)
+                if hasIgnoreExprs:
+                    preloc = self_skip_ignorables( instring, loc )
+                else:
+                    preloc = loc
+                loc, tmptokens = self_expr_parse( instring, preloc, doActions )
+                if tmptokens or tmptokens.haskeys():
+                    tokens += tmptokens
+        except (ParseException,IndexError):
+            pass
+
+        return loc, tokens
+        
+class OneOrMore(_MultipleMatch):
+    """
+    Repetition of one or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match one or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: BLACK"
+        OneOrMore(attr_expr).parseString(text).pprint()  # Fail! read 'color' as data instead of next label -> [['shape', 'SQUARE color']]
+
+        # use stopOn attribute for OneOrMore to avoid reading label string as part of the data
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        OneOrMore(attr_expr).parseString(text).pprint() # Better -> [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'BLACK']]
+        
+        # could also be written as
+        (attr_expr * (1,)).parseString(text).pprint()
+    """
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "{" + _ustr(self.expr) + "}..."
+
+        return self.strRepr
+
+class ZeroOrMore(_MultipleMatch):
+    """
+    Optional repetition of zero or more of the given expression.
+    
+    Parameters:
+     - expr - expression that must match zero or more times
+     - stopOn - (default=C{None}) - expression for a terminating sentinel
+          (only required if the sentinel would ordinarily match the repetition 
+          expression)          
+
+    Example: similar to L{OneOrMore}
+    """
+    def __init__( self, expr, stopOn=None):
+        super(ZeroOrMore,self).__init__(expr, stopOn=stopOn)
+        self.mayReturnEmpty = True
+        
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            return super(ZeroOrMore, self).parseImpl(instring, loc, doActions)
+        except (ParseException,IndexError):
+            return loc, []
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]..."
+
+        return self.strRepr
+
+class _NullToken(object):
+    def __bool__(self):
+        return False
+    __nonzero__ = __bool__
+    def __str__(self):
+        return ""
+
+_optionalNotMatched = _NullToken()
+class Optional(ParseElementEnhance):
+    """
+    Optional matching of the given expression.
+
+    Parameters:
+     - expr - expression that must match zero or more times
+     - default (optional) - value to be returned if the optional expression is not found.
+
+    Example::
+        # US postal code can be a 5-digit zip, plus optional 4-digit qualifier
+        zip = Combine(Word(nums, exact=5) + Optional('-' + Word(nums, exact=4)))
+        zip.runTests('''
+            # traditional ZIP code
+            12345
+            
+            # ZIP+4 form
+            12101-0001
+            
+            # invalid ZIP
+            98765-
+            ''')
+    prints::
+        # traditional ZIP code
+        12345
+        ['12345']
+
+        # ZIP+4 form
+        12101-0001
+        ['12101-0001']
+
+        # invalid ZIP
+        98765-
+             ^
+        FAIL: Expected end of text (at char 5), (line:1, col:6)
+    """
+    def __init__( self, expr, default=_optionalNotMatched ):
+        super(Optional,self).__init__( expr, savelist=False )
+        self.saveAsList = self.expr.saveAsList
+        self.defaultValue = default
+        self.mayReturnEmpty = True
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        try:
+            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
+        except (ParseException,IndexError):
+            if self.defaultValue is not _optionalNotMatched:
+                if self.expr.resultsName:
+                    tokens = ParseResults([ self.defaultValue ])
+                    tokens[self.expr.resultsName] = self.defaultValue
+                else:
+                    tokens = [ self.defaultValue ]
+            else:
+                tokens = []
+        return loc, tokens
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+
+        if self.strRepr is None:
+            self.strRepr = "[" + _ustr(self.expr) + "]"
+
+        return self.strRepr
+
+class SkipTo(ParseElementEnhance):
+    """
+    Token for skipping over all undefined text until the matched expression is found.
+
+    Parameters:
+     - expr - target expression marking the end of the data to be skipped
+     - include - (default=C{False}) if True, the target expression is also parsed 
+          (the skipped text and target expression are returned as a 2-element list).
+     - ignore - (default=C{None}) used to define grammars (typically quoted strings and 
+          comments) that might contain false matches to the target expression
+     - failOn - (default=C{None}) define expressions that are not allowed to be 
+          included in the skipped test; if found before the target expression is found, 
+          the SkipTo is not a match
+
+    Example::
+        report = '''
+            Outstanding Issues Report - 1 Jan 2000
+
+               # | Severity | Description                               |  Days Open
+            -----+----------+-------------------------------------------+-----------
+             101 | Critical | Intermittent system crash                 |          6
+              94 | Cosmetic | Spelling error on Login ('log|n')         |         14
+              79 | Minor    | System slow when running too many reports |         47
+            '''
+        integer = Word(nums)
+        SEP = Suppress('|')
+        # use SkipTo to simply match everything up until the next SEP
+        # - ignore quoted strings, so that a '|' character inside a quoted string does not match
+        # - parse action will call token.strip() for each matched token, i.e., the description body
+        string_data = SkipTo(SEP, ignore=quotedString)
+        string_data.setParseAction(tokenMap(str.strip))
+        ticket_expr = (integer("issue_num") + SEP 
+                      + string_data("sev") + SEP 
+                      + string_data("desc") + SEP 
+                      + integer("days_open"))
+        
+        for tkt in ticket_expr.searchString(report):
+            print tkt.dump()
+    prints::
+        ['101', 'Critical', 'Intermittent system crash', '6']
+        - days_open: 6
+        - desc: Intermittent system crash
+        - issue_num: 101
+        - sev: Critical
+        ['94', 'Cosmetic', "Spelling error on Login ('log|n')", '14']
+        - days_open: 14
+        - desc: Spelling error on Login ('log|n')
+        - issue_num: 94
+        - sev: Cosmetic
+        ['79', 'Minor', 'System slow when running too many reports', '47']
+        - days_open: 47
+        - desc: System slow when running too many reports
+        - issue_num: 79
+        - sev: Minor
+    """
+    def __init__( self, other, include=False, ignore=None, failOn=None ):
+        super( SkipTo, self ).__init__( other )
+        self.ignoreExpr = ignore
+        self.mayReturnEmpty = True
+        self.mayIndexError = False
+        self.includeMatch = include
+        self.asList = False
+        if isinstance(failOn, basestring):
+            self.failOn = ParserElement._literalStringClass(failOn)
+        else:
+            self.failOn = failOn
+        self.errmsg = "No match found for "+_ustr(self.expr)
+
+    def parseImpl( self, instring, loc, doActions=True ):
+        startloc = loc
+        instrlen = len(instring)
+        expr = self.expr
+        expr_parse = self.expr._parse
+        self_failOn_canParseNext = self.failOn.canParseNext if self.failOn is not None else None
+        self_ignoreExpr_tryParse = self.ignoreExpr.tryParse if self.ignoreExpr is not None else None
+        
+        tmploc = loc
+        while tmploc <= instrlen:
+            if self_failOn_canParseNext is not None:
+                # break if failOn expression matches
+                if self_failOn_canParseNext(instring, tmploc):
+                    break
+                    
+            if self_ignoreExpr_tryParse is not None:
+                # advance past ignore expressions
+                while 1:
+                    try:
+                        tmploc = self_ignoreExpr_tryParse(instring, tmploc)
+                    except ParseBaseException:
+                        break
+            
+            try:
+                expr_parse(instring, tmploc, doActions=False, callPreParse=False)
+            except (ParseException, IndexError):
+                # no match, advance loc in string
+                tmploc += 1
+            else:
+                # matched skipto expr, done
+                break
+
+        else:
+            # ran off the end of the input string without matching skipto expr, fail
+            raise ParseException(instring, loc, self.errmsg, self)
+
+        # build up return values
+        loc = tmploc
+        skiptext = instring[startloc:loc]
+        skipresult = ParseResults(skiptext)
+        
+        if self.includeMatch:
+            loc, mat = expr_parse(instring,loc,doActions,callPreParse=False)
+            skipresult += mat
+
+        return loc, skipresult
+
+class Forward(ParseElementEnhance):
+    """
+    Forward declaration of an expression to be defined later -
+    used for recursive grammars, such as algebraic infix notation.
+    When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
+
+    Note: take care when assigning to C{Forward} not to overlook precedence of operators.
+    Specifically, '|' has a lower precedence than '<<', so that::
+        fwdExpr << a | b | c
+    will actually be evaluated as::
+        (fwdExpr << a) | b | c
+    thereby leaving b and c out as parseable alternatives.  It is recommended that you
+    explicitly group the values inserted into the C{Forward}::
+        fwdExpr << (a | b | c)
+    Converting to use the '<<=' operator instead will avoid this problem.
+
+    See L{ParseResults.pprint} for an example of a recursive parser created using
+    C{Forward}.
+    """
+    def __init__( self, other=None ):
+        super(Forward,self).__init__( other, savelist=False )
+
+    def __lshift__( self, other ):
+        if isinstance( other, basestring ):
+            other = ParserElement._literalStringClass(other)
+        self.expr = other
+        self.strRepr = None
+        self.mayIndexError = self.expr.mayIndexError
+        self.mayReturnEmpty = self.expr.mayReturnEmpty
+        self.setWhitespaceChars( self.expr.whiteChars )
+        self.skipWhitespace = self.expr.skipWhitespace
+        self.saveAsList = self.expr.saveAsList
+        self.ignoreExprs.extend(self.expr.ignoreExprs)
+        return self
+        
+    def __ilshift__(self, other):
+        return self << other
+    
+    def leaveWhitespace( self ):
+        self.skipWhitespace = False
+        return self
+
+    def streamline( self ):
+        if not self.streamlined:
+            self.streamlined = True
+            if self.expr is not None:
+                self.expr.streamline()
+        return self
+
+    def validate( self, validateTrace=[] ):
+        if self not in validateTrace:
+            tmp = validateTrace[:]+[self]
+            if self.expr is not None:
+                self.expr.validate(tmp)
+        self.checkRecursion([])
+
+    def __str__( self ):
+        if hasattr(self,"name"):
+            return self.name
+        return self.__class__.__name__ + ": ..."
+
+        # stubbed out for now - creates awful memory and perf issues
+        self._revertClass = self.__class__
+        self.__class__ = _ForwardNoRecurse
+        try:
+            if self.expr is not None:
+                retString = _ustr(self.expr)
+            else:
+                retString = "None"
+        finally:
+            self.__class__ = self._revertClass
+        return self.__class__.__name__ + ": " + retString
+
+    def copy(self):
+        if self.expr is not None:
+            return super(Forward,self).copy()
+        else:
+            ret = Forward()
+            ret <<= self
+            return ret
+
+class _ForwardNoRecurse(Forward):
+    def __str__( self ):
+        return "..."
+
+class TokenConverter(ParseElementEnhance):
+    """
+    Abstract subclass of C{ParseExpression}, for converting parsed results.
+    """
+    def __init__( self, expr, savelist=False ):
+        super(TokenConverter,self).__init__( expr )#, savelist )
+        self.saveAsList = False
+
+class Combine(TokenConverter):
+    """
+    Converter to concatenate all matching tokens to a single string.
+    By default, the matching patterns must also be contiguous in the input string;
+    this can be disabled by specifying C{'adjacent=False'} in the constructor.
+
+    Example::
+        real = Word(nums) + '.' + Word(nums)
+        print(real.parseString('3.1416')) # -> ['3', '.', '1416']
+        # will also erroneously match the following
+        print(real.parseString('3. 1416')) # -> ['3', '.', '1416']
+
+        real = Combine(Word(nums) + '.' + Word(nums))
+        print(real.parseString('3.1416')) # -> ['3.1416']
+        # no match when there are internal spaces
+        print(real.parseString('3. 1416')) # -> Exception: Expected W:(0123...)
+    """
+    def __init__( self, expr, joinString="", adjacent=True ):
+        super(Combine,self).__init__( expr )
+        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
+        if adjacent:
+            self.leaveWhitespace()
+        self.adjacent = adjacent
+        self.skipWhitespace = True
+        self.joinString = joinString
+        self.callPreparse = True
+
+    def ignore( self, other ):
+        if self.adjacent:
+            ParserElement.ignore(self, other)
+        else:
+            super( Combine, self).ignore( other )
+        return self
+
+    def postParse( self, instring, loc, tokenlist ):
+        retToks = tokenlist.copy()
+        del retToks[:]
+        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
+
+        if self.resultsName and retToks.haskeys():
+            return [ retToks ]
+        else:
+            return retToks
+
+class Group(TokenConverter):
+    """
+    Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions.
+
+    Example::
+        ident = Word(alphas)
+        num = Word(nums)
+        term = ident | num
+        func = ident + Optional(delimitedList(term))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', 'a', 'b', '100']
+
+        func = ident + Group(Optional(delimitedList(term)))
+        print(func.parseString("fn a,b,100"))  # -> ['fn', ['a', 'b', '100']]
+    """
+    def __init__( self, expr ):
+        super(Group,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        return [ tokenlist ]
+
+class Dict(TokenConverter):
+    """
+    Converter to return a repetitive expression as a list, but also as a dictionary.
+    Each element can also be referenced using the first token in the expression as its key.
+    Useful for tabular report scraping when the first column can be used as a item key.
+
+    Example::
+        data_word = Word(alphas)
+        label = data_word + FollowedBy(':')
+        attr_expr = Group(label + Suppress(':') + OneOrMore(data_word).setParseAction(' '.join))
+
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        
+        # print attributes as plain groups
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        # instead of OneOrMore(expr), parse using Dict(OneOrMore(Group(expr))) - Dict will auto-assign names
+        result = Dict(OneOrMore(Group(attr_expr))).parseString(text)
+        print(result.dump())
+        
+        # access named fields as dict entries, or output as dict
+        print(result['shape'])        
+        print(result.asDict())
+    prints::
+        ['shape', 'SQUARE', 'posn', 'upper left', 'color', 'light blue', 'texture', 'burlap']
+
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        {'color': 'light blue', 'posn': 'upper left', 'texture': 'burlap', 'shape': 'SQUARE'}
+    See more examples at L{ParseResults} of accessing fields by results name.
+    """
+    def __init__( self, expr ):
+        super(Dict,self).__init__( expr )
+        self.saveAsList = True
+
+    def postParse( self, instring, loc, tokenlist ):
+        for i,tok in enumerate(tokenlist):
+            if len(tok) == 0:
+                continue
+            ikey = tok[0]
+            if isinstance(ikey,int):
+                ikey = _ustr(tok[0]).strip()
+            if len(tok)==1:
+                tokenlist[ikey] = _ParseResultsWithOffset("",i)
+            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
+                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
+            else:
+                dictvalue = tok.copy() #ParseResults(i)
+                del dictvalue[0]
+                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
+                else:
+                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
+
+        if self.resultsName:
+            return [ tokenlist ]
+        else:
+            return tokenlist
+
+
+class Suppress(TokenConverter):
+    """
+    Converter for ignoring the results of a parsed expression.
+
+    Example::
+        source = "a, b, c,d"
+        wd = Word(alphas)
+        wd_list1 = wd + ZeroOrMore(',' + wd)
+        print(wd_list1.parseString(source))
+
+        # often, delimiters that are useful during parsing are just in the
+        # way afterward - use Suppress to keep them out of the parsed output
+        wd_list2 = wd + ZeroOrMore(Suppress(',') + wd)
+        print(wd_list2.parseString(source))
+    prints::
+        ['a', ',', 'b', ',', 'c', ',', 'd']
+        ['a', 'b', 'c', 'd']
+    (See also L{delimitedList}.)
+    """
+    def postParse( self, instring, loc, tokenlist ):
+        return []
+
+    def suppress( self ):
+        return self
+
+
+class OnlyOnce(object):
+    """
+    Wrapper for parse actions, to ensure they are only called once.
+    """
+    def __init__(self, methodCall):
+        self.callable = _trim_arity(methodCall)
+        self.called = False
+    def __call__(self,s,l,t):
+        if not self.called:
+            results = self.callable(s,l,t)
+            self.called = True
+            return results
+        raise ParseException(s,l,"")
+    def reset(self):
+        self.called = False
+
+def traceParseAction(f):
+    """
+    Decorator for debugging parse actions. 
+    
+    When the parse action is called, this decorator will print C{">> entering I{method-name}(line:I{current_source_line}, I{parse_location}, I{matched_tokens})".}
+    When the parse action completes, the decorator will print C{"<<"} followed by the returned value, or any exception that the parse action raised.
+
+    Example::
+        wd = Word(alphas)
+
+        @traceParseAction
+        def remove_duplicate_chars(tokens):
+            return ''.join(sorted(set(''.join(tokens))))
+
+        wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
+        print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
+    prints::
+        >>entering remove_duplicate_chars(line: 'slkdjs sld sldd sdlf sdljf', 0, (['slkdjs', 'sld', 'sldd', 'sdlf', 'sdljf'], {}))
+        <<leaving remove_duplicate_chars (ret: 'dfjkls')
+        ['dfjkls']
+    """
+    f = _trim_arity(f)
+    def z(*paArgs):
+        thisFunc = f.__name__
+        s,l,t = paArgs[-3:]
+        if len(paArgs)>3:
+            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
+        sys.stderr.write( ">>entering %s(line: '%s', %d, %r)\n" % (thisFunc,line(l,s),l,t) )
+        try:
+            ret = f(*paArgs)
+        except Exception as exc:
+            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
+            raise
+        sys.stderr.write( "<<leaving %s (ret: %r)\n" % (thisFunc,ret) )
+        return ret
+    try:
+        z.__name__ = f.__name__
+    except AttributeError:
+        pass
+    return z
+
+#
+# global helpers
+#
+def delimitedList( expr, delim=",", combine=False ):
+    """
+    Helper to define a delimited list of expressions - the delimiter defaults to ','.
+    By default, the list elements and delimiters can have intervening whitespace, and
+    comments, but this can be overridden by passing C{combine=True} in the constructor.
+    If C{combine} is set to C{True}, the matching tokens are returned as a single token
+    string, with the delimiters included; otherwise, the matching tokens are returned
+    as a list of tokens, with the delimiters suppressed.
+
+    Example::
+        delimitedList(Word(alphas)).parseString("aa,bb,cc") # -> ['aa', 'bb', 'cc']
+        delimitedList(Word(hexnums), delim=':', combine=True).parseString("AA:BB:CC:DD:EE") # -> ['AA:BB:CC:DD:EE']
+    """
+    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
+    if combine:
+        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
+    else:
+        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)
+
+def countedArray( expr, intExpr=None ):
+    """
+    Helper to define a counted list of expressions.
+    This helper defines a pattern of the form::
+        integer expr expr expr...
+    where the leading integer tells how many expr expressions follow.
+    The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
+    
+    If C{intExpr} is specified, it should be a pyparsing expression that produces an integer value.
+
+    Example::
+        countedArray(Word(alphas)).parseString('2 ab cd ef')  # -> ['ab', 'cd']
+
+        # in this parser, the leading integer value is given in binary,
+        # '10' indicating that 2 values are in the array
+        binaryConstant = Word('01').setParseAction(lambda t: int(t[0], 2))
+        countedArray(Word(alphas), intExpr=binaryConstant).parseString('10 ab cd ef')  # -> ['ab', 'cd']
+    """
+    arrayExpr = Forward()
+    def countFieldParseAction(s,l,t):
+        n = t[0]
+        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
+        return []
+    if intExpr is None:
+        intExpr = Word(nums).setParseAction(lambda t:int(t[0]))
+    else:
+        intExpr = intExpr.copy()
+    intExpr.setName("arrayLen")
+    intExpr.addParseAction(countFieldParseAction, callDuringTry=True)
+    return ( intExpr + arrayExpr ).setName('(len) ' + _ustr(expr) + '...')
+
+def _flatten(L):
+    ret = []
+    for i in L:
+        if isinstance(i,list):
+            ret.extend(_flatten(i))
+        else:
+            ret.append(i)
+    return ret
+
+def matchPreviousLiteral(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousLiteral(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches a
+    previous literal, will also match the leading C{"1:1"} in C{"1:10"}.
+    If this is not desired, use C{matchPreviousExpr}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    def copyTokenToRepeater(s,l,t):
+        if t:
+            if len(t) == 1:
+                rep << t[0]
+            else:
+                # flatten t tokens
+                tflat = _flatten(t.asList())
+                rep << And(Literal(tt) for tt in tflat)
+        else:
+            rep << Empty()
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def matchPreviousExpr(expr):
+    """
+    Helper to define an expression that is indirectly defined from
+    the tokens matched in a previous expression, that is, it looks
+    for a 'repeat' of a previous expression.  For example::
+        first = Word(nums)
+        second = matchPreviousExpr(first)
+        matchExpr = first + ":" + second
+    will match C{"1:1"}, but not C{"1:2"}.  Because this matches by
+    expressions, will I{not} match the leading C{"1:1"} in C{"1:10"};
+    the expressions are evaluated first, and then compared, so
+    C{"1"} is compared with C{"10"}.
+    Do I{not} use with packrat parsing enabled.
+    """
+    rep = Forward()
+    e2 = expr.copy()
+    rep <<= e2
+    def copyTokenToRepeater(s,l,t):
+        matchTokens = _flatten(t.asList())
+        def mustMatchTheseTokens(s,l,t):
+            theseTokens = _flatten(t.asList())
+            if  theseTokens != matchTokens:
+                raise ParseException("",0,"")
+        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
+    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
+    rep.setName('(prev) ' + _ustr(expr))
+    return rep
+
+def _escapeRegexRangeChars(s):
+    #~  escape these chars: ^-]
+    for c in r"\^-]":
+        s = s.replace(c,_bslash+c)
+    s = s.replace("\n",r"\n")
+    s = s.replace("\t",r"\t")
+    return _ustr(s)
+
+def oneOf( strs, caseless=False, useRegex=True ):
+    """
+    Helper to quickly define a set of alternative Literals, and makes sure to do
+    longest-first testing when there is a conflict, regardless of the input order,
+    but returns a C{L{MatchFirst}} for best performance.
+
+    Parameters:
+     - strs - a string of space-delimited literals, or a collection of string literals
+     - caseless - (default=C{False}) - treat all literals as caseless
+     - useRegex - (default=C{True}) - as an optimization, will generate a Regex
+          object; otherwise, will generate a C{MatchFirst} object (if C{caseless=True}, or
+          if creating a C{Regex} raises an exception)
+
+    Example::
+        comp_oper = oneOf("< = > <= >= !=")
+        var = Word(alphas)
+        number = Word(nums)
+        term = var | number
+        comparison_expr = term + comp_oper + term
+        print(comparison_expr.searchString("B = 12  AA=23 B<=AA AA>12"))
+    prints::
+        [['B', '=', '12'], ['AA', '=', '23'], ['B', '<=', 'AA'], ['AA', '>', '12']]
+    """
+    if caseless:
+        isequal = ( lambda a,b: a.upper() == b.upper() )
+        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
+        parseElementClass = CaselessLiteral
+    else:
+        isequal = ( lambda a,b: a == b )
+        masks = ( lambda a,b: b.startswith(a) )
+        parseElementClass = Literal
+
+    symbols = []
+    if isinstance(strs,basestring):
+        symbols = strs.split()
+    elif isinstance(strs, Iterable):
+        symbols = list(strs)
+    else:
+        warnings.warn("Invalid argument to oneOf, expected string or iterable",
+                SyntaxWarning, stacklevel=2)
+    if not symbols:
+        return NoMatch()
+
+    i = 0
+    while i < len(symbols)-1:
+        cur = symbols[i]
+        for j,other in enumerate(symbols[i+1:]):
+            if ( isequal(other, cur) ):
+                del symbols[i+j+1]
+                break
+            elif ( masks(cur, other) ):
+                del symbols[i+j+1]
+                symbols.insert(i,other)
+                cur = other
+                break
+        else:
+            i += 1
+
+    if not caseless and useRegex:
+        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
+        try:
+            if len(symbols)==len("".join(symbols)):
+                return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) ).setName(' | '.join(symbols))
+            else:
+                return Regex( "|".join(re.escape(sym) for sym in symbols) ).setName(' | '.join(symbols))
+        except Exception:
+            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
+                    SyntaxWarning, stacklevel=2)
+
+
+    # last resort, just use MatchFirst
+    return MatchFirst(parseElementClass(sym) for sym in symbols).setName(' | '.join(symbols))
+
+def dictOf( key, value ):
+    """
+    Helper to easily and clearly define a dictionary by specifying the respective patterns
+    for the key and value.  Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
+    in the proper order.  The key pattern can include delimiting markers or punctuation,
+    as long as they are suppressed, thereby leaving the significant key text.  The value
+    pattern can include named results, so that the C{Dict} results can include named token
+    fields.
+
+    Example::
+        text = "shape: SQUARE posn: upper left color: light blue texture: burlap"
+        attr_expr = (label + Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join))
+        print(OneOrMore(attr_expr).parseString(text).dump())
+        
+        attr_label = label
+        attr_value = Suppress(':') + OneOrMore(data_word, stopOn=label).setParseAction(' '.join)
+
+        # similar to Dict, but simpler call format
+        result = dictOf(attr_label, attr_value).parseString(text)
+        print(result.dump())
+        print(result['shape'])
+        print(result.shape)  # object attribute access works too
+        print(result.asDict())
+    prints::
+        [['shape', 'SQUARE'], ['posn', 'upper left'], ['color', 'light blue'], ['texture', 'burlap']]
+        - color: light blue
+        - posn: upper left
+        - shape: SQUARE
+        - texture: burlap
+        SQUARE
+        SQUARE
+        {'color': 'light blue', 'shape': 'SQUARE', 'posn': 'upper left', 'texture': 'burlap'}
+    """
+    return Dict( ZeroOrMore( Group ( key + value ) ) )
+
+def originalTextFor(expr, asString=True):
+    """
+    Helper to return the original, untokenized text for a given expression.  Useful to
+    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
+    revert separate tokens with intervening whitespace back to the original matching
+    input text. By default, returns astring containing the original parsed text.  
+       
+    If the optional C{asString} argument is passed as C{False}, then the return value is a 
+    C{L{ParseResults}} containing any results names that were originally matched, and a 
+    single token containing the original matched text from the input string.  So if 
+    the expression passed to C{L{originalTextFor}} contains expressions with defined
+    results names, you must set C{asString} to C{False} if you want to preserve those
+    results name values.
+
+    Example::
+        src = "this is test <b> bold <i>text</i> </b> normal text "
+        for tag in ("b","i"):
+            opener,closer = makeHTMLTags(tag)
+            patt = originalTextFor(opener + SkipTo(closer) + closer)
+            print(patt.searchString(src)[0])
+    prints::
+        ['<b> bold <i>text</i> </b>']
+        ['<i>text</i>']
+    """
+    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
+    endlocMarker = locMarker.copy()
+    endlocMarker.callPreparse = False
+    matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
+    if asString:
+        extractText = lambda s,l,t: s[t._original_start:t._original_end]
+    else:
+        def extractText(s,l,t):
+            t[:] = [s[t.pop('_original_start'):t.pop('_original_end')]]
+    matchExpr.setParseAction(extractText)
+    matchExpr.ignoreExprs = expr.ignoreExprs
+    return matchExpr
+
+def ungroup(expr): 
+    """
+    Helper to undo pyparsing's default grouping of And expressions, even
+    if all but one are non-empty.
+    """
+    return TokenConverter(expr).setParseAction(lambda t:t[0])
+
+def locatedExpr(expr):
+    """
+    Helper to decorate a returned token with its starting and ending locations in the input string.
+    This helper adds the following results names:
+     - locn_start = location where matched expression begins
+     - locn_end = location where matched expression ends
+     - value = the actual parsed results
+
+    Be careful if the input text contains C{<TAB>} characters, you may want to call
+    C{L{ParserElement.parseWithTabs}}
+
+    Example::
+        wd = Word(alphas)
+        for match in locatedExpr(wd).searchString("ljsdf123lksdjjf123lkkjj1222"):
+            print(match)
+    prints::
+        [[0, 'ljsdf', 5]]
+        [[8, 'lksdjjf', 15]]
+        [[18, 'lkkjj', 23]]
+    """
+    locator = Empty().setParseAction(lambda s,l,t: l)
+    return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
+
+
+# convenience constants for positional expressions
+empty       = Empty().setName("empty")
+lineStart   = LineStart().setName("lineStart")
+lineEnd     = LineEnd().setName("lineEnd")
+stringStart = StringStart().setName("stringStart")
+stringEnd   = StringEnd().setName("stringEnd")
+
+_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
+_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
+_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
+_charRange = Group(_singleChar + Suppress("-") + _singleChar)
+_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
+
+def srange(s):
+    r"""
+    Helper to easily define string ranges for use in Word construction.  Borrows
+    syntax from regexp '[]' string range definitions::
+        srange("[0-9]")   -> "0123456789"
+        srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
+        srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
+    The input string must be enclosed in []'s, and the returned string is the expanded
+    character set joined into a single string.
+    The values enclosed in the []'s may be:
+     - a single character
+     - an escaped character with a leading backslash (such as C{\-} or C{\]})
+     - an escaped hex character with a leading C{'\x'} (C{\x21}, which is a C{'!'} character) 
+         (C{\0x##} is also supported for backwards compatibility) 
+     - an escaped octal character with a leading C{'\0'} (C{\041}, which is a C{'!'} character)
+     - a range of any of the above, separated by a dash (C{'a-z'}, etc.)
+     - any combination of the above (C{'aeiouy'}, C{'a-zA-Z0-9_$'}, etc.)
+    """
+    _expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
+    try:
+        return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
+    except Exception:
+        return ""
+
+def matchOnlyAtCol(n):
+    """
+    Helper method for defining parse actions that require matching at a specific
+    column in the input text.
+    """
+    def verifyCol(strg,locn,toks):
+        if col(locn,strg) != n:
+            raise ParseException(strg,locn,"matched token not at column %d" % n)
+    return verifyCol
+
+def replaceWith(replStr):
+    """
+    Helper method for common parse actions that simply return a literal value.  Especially
+    useful when used with C{L{transformString<ParserElement.transformString>}()}.
+
+    Example::
+        num = Word(nums).setParseAction(lambda toks: int(toks[0]))
+        na = oneOf("N/A NA").setParseAction(replaceWith(math.nan))
+        term = na | num
+        
+        OneOrMore(term).parseString("324 234 N/A 234") # -> [324, 234, nan, 234]
+    """
+    return lambda s,l,t: [replStr]
+
+def removeQuotes(s,l,t):
+    """
+    Helper parse action for removing quotation marks from parsed quoted strings.
+
+    Example::
+        # by default, quotation marks are included in parsed results
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["'Now is the Winter of our Discontent'"]
+
+        # use removeQuotes to strip quotation marks from parsed results
+        quotedString.setParseAction(removeQuotes)
+        quotedString.parseString("'Now is the Winter of our Discontent'") # -> ["Now is the Winter of our Discontent"]
+    """
+    return t[0][1:-1]
+
+def tokenMap(func, *args):
+    """
+    Helper to define a parse action by mapping a function to all elements of a ParseResults list.If any additional 
+    args are passed, they are forwarded to the given function as additional arguments after
+    the token, as in C{hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))}, which will convert the
+    parsed data to an integer using base 16.
+
+    Example (compare the last to example in L{ParserElement.transformString}::
+        hex_ints = OneOrMore(Word(hexnums)).setParseAction(tokenMap(int, 16))
+        hex_ints.runTests('''
+            00 11 22 aa FF 0a 0d 1a
+            ''')
+        
+        upperword = Word(alphas).setParseAction(tokenMap(str.upper))
+        OneOrMore(upperword).runTests('''
+            my kingdom for a horse
+            ''')
+
+        wd = Word(alphas).setParseAction(tokenMap(str.title))
+        OneOrMore(wd).setParseAction(' '.join).runTests('''
+            now is the winter of our discontent made glorious summer by this sun of york
+            ''')
+    prints::
+        00 11 22 aa FF 0a 0d 1a
+        [0, 17, 34, 170, 255, 10, 13, 26]
+
+        my kingdom for a horse
+        ['MY', 'KINGDOM', 'FOR', 'A', 'HORSE']
+
+        now is the winter of our discontent made glorious summer by this sun of york
+        ['Now Is The Winter Of Our Discontent Made Glorious Summer By This Sun Of York']
+    """
+    def pa(s,l,t):
+        return [func(tokn, *args) for tokn in t]
+
+    try:
+        func_name = getattr(func, '__name__', 
+                            getattr(func, '__class__').__name__)
+    except Exception:
+        func_name = str(func)
+    pa.__name__ = func_name
+
+    return pa
+
+upcaseTokens = tokenMap(lambda t: _ustr(t).upper())
+"""(Deprecated) Helper parse action to convert tokens to upper case. Deprecated in favor of L{pyparsing_common.upcaseTokens}"""
+
+downcaseTokens = tokenMap(lambda t: _ustr(t).lower())
+"""(Deprecated) Helper parse action to convert tokens to lower case. Deprecated in favor of L{pyparsing_common.downcaseTokens}"""
+    
+def _makeTags(tagStr, xml):
+    """Internal helper to construct opening and closing tag expressions, given a tag name"""
+    if isinstance(tagStr,basestring):
+        resname = tagStr
+        tagStr = Keyword(tagStr, caseless=not xml)
+    else:
+        resname = tagStr.name
+
+    tagAttrName = Word(alphas,alphanums+"_-:")
+    if (xml):
+        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    else:
+        printablesLessRAbrack = "".join(c for c in printables if c not in ">")
+        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
+        openTag = Suppress("<") + tagStr("tag") + \
+                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
+                Optional( Suppress("=") + tagAttrValue ) ))) + \
+                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
+    closeTag = Combine(_L("</") + tagStr + ">")
+
+    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % resname)
+    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % resname)
+    openTag.tag = resname
+    closeTag.tag = resname
+    return openTag, closeTag
+
+def makeHTMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for HTML, given a tag name. Matches
+    tags in either upper or lower case, attributes with namespaces and with quoted or unquoted values.
+
+    Example::
+        text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+        # makeHTMLTags returns pyparsing expressions for the opening and closing tags as a 2-tuple
+        a,a_end = makeHTMLTags("A")
+        link_expr = a + SkipTo(a_end)("link_text") + a_end
+        
+        for link in link_expr.searchString(text):
+            # attributes in the <A> tag (like "href" shown here) are also accessible as named results
+            print(link.link_text, '->', link.href)
+    prints::
+        pyparsing -> http://pyparsing.wikispaces.com
+    """
+    return _makeTags( tagStr, False )
+
+def makeXMLTags(tagStr):
+    """
+    Helper to construct opening and closing tag expressions for XML, given a tag name. Matches
+    tags only in the given upper/lower case.
+
+    Example: similar to L{makeHTMLTags}
+    """
+    return _makeTags( tagStr, True )
+
+def withAttribute(*args,**attrDict):
+    """
+    Helper to create a validating parse action to be used with start tags created
+    with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
+    with a required attribute value, to avoid false matches on common tags such as
+    C{<TD>} or C{<DIV>}.
+
+    Call C{withAttribute} with a series of attribute names and values. Specify the list
+    of filter attributes names and values as:
+     - keyword arguments, as in C{(align="right")}, or
+     - as an explicit dict with C{**} operator, when an attribute name is also a Python
+          reserved word, as in C{**{"class":"Customer", "align":"right"}}
+     - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
+    For attribute names with a namespace prefix, you must use the second form.  Attribute
+    names are matched insensitive to upper/lower case.
+       
+    If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
+
+    To verify that the attribute exists, but without specifying a value, pass
+    C{withAttribute.ANY_VALUE} as the value.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div type="grid">1 4 0 1 0</div>
+            <div type="graph">1,3 2,3 1,1</div>
+            <div>this has no type</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+
+        # only match div tag having a type attribute with value "grid"
+        div_grid = div().setParseAction(withAttribute(type="grid"))
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        # construct a match with any div tag having a type attribute, regardless of the value
+        div_any_type = div().setParseAction(withAttribute(type=withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    if args:
+        attrs = args[:]
+    else:
+        attrs = attrDict.items()
+    attrs = [(k,v) for k,v in attrs]
+    def pa(s,l,tokens):
+        for attrName,attrValue in attrs:
+            if attrName not in tokens:
+                raise ParseException(s,l,"no matching attribute " + attrName)
+            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
+                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
+                                            (attrName, tokens[attrName], attrValue))
+    return pa
+withAttribute.ANY_VALUE = object()
+
+def withClass(classname, namespace=''):
+    """
+    Simplified version of C{L{withAttribute}} when matching on a div class - made
+    difficult because C{class} is a reserved word in Python.
+
+    Example::
+        html = '''
+            <div>
+            Some text
+            <div class="grid">1 4 0 1 0</div>
+            <div class="graph">1,3 2,3 1,1</div>
+            <div>this &lt;div&gt; has no class</div>
+            </div>
+                
+        '''
+        div,div_end = makeHTMLTags("div")
+        div_grid = div().setParseAction(withClass("grid"))
+        
+        grid_expr = div_grid + SkipTo(div | div_end)("body")
+        for grid_header in grid_expr.searchString(html):
+            print(grid_header.body)
+        
+        div_any_type = div().setParseAction(withClass(withAttribute.ANY_VALUE))
+        div_expr = div_any_type + SkipTo(div | div_end)("body")
+        for div_header in div_expr.searchString(html):
+            print(div_header.body)
+    prints::
+        1 4 0 1 0
+
+        1 4 0 1 0
+        1,3 2,3 1,1
+    """
+    classattr = "%s:class" % namespace if namespace else "class"
+    return withAttribute(**{classattr : classname})        
+
+opAssoc = _Constants()
+opAssoc.LEFT = object()
+opAssoc.RIGHT = object()
+
+def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
+    """
+    Helper method for constructing grammars of expressions made up of
+    operators working in a precedence hierarchy.  Operators may be unary or
+    binary, left- or right-associative.  Parse actions can also be attached
+    to operator expressions. The generated parser will also recognize the use 
+    of parentheses to override operator precedences (see example below).
+    
+    Note: if you define a deep operator list, you may see performance issues
+    when using infixNotation. See L{ParserElement.enablePackrat} for a
+    mechanism to potentially improve your parser performance.
+
+    Parameters:
+     - baseExpr - expression representing the most basic element for the nested
+     - opList - list of tuples, one for each operator precedence level in the
+      expression grammar; each tuple is of the form
+      (opExpr, numTerms, rightLeftAssoc, parseAction), where:
+       - opExpr is the pyparsing expression for the operator;
+          may also be a string, which will be converted to a Literal;
+          if numTerms is 3, opExpr is a tuple of two expressions, for the
+          two operators separating the 3 terms
+       - numTerms is the number of terms for this operator (must
+          be 1, 2, or 3)
+       - rightLeftAssoc is the indicator whether the operator is
+          right or left associative, using the pyparsing-defined
+          constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
+       - parseAction is the parse action to be associated with
+          expressions matching this operator expression (the
+          parse action tuple member may be omitted); if the parse action
+          is passed a tuple or list of functions, this is equivalent to
+          calling C{setParseAction(*fn)} (L{ParserElement.setParseAction})
+     - lpar - expression for matching left-parentheses (default=C{Suppress('(')})
+     - rpar - expression for matching right-parentheses (default=C{Suppress(')')})
+
+    Example::
+        # simple example of four-function arithmetic with ints and variable names
+        integer = pyparsing_common.signed_integer
+        varname = pyparsing_common.identifier 
+        
+        arith_expr = infixNotation(integer | varname,
+            [
+            ('-', 1, opAssoc.RIGHT),
+            (oneOf('* /'), 2, opAssoc.LEFT),
+            (oneOf('+ -'), 2, opAssoc.LEFT),
+            ])
+        
+        arith_expr.runTests('''
+            5+3*6
+            (5+3)*6
+            -2--11
+            ''', fullDump=False)
+    prints::
+        5+3*6
+        [[5, '+', [3, '*', 6]]]
+
+        (5+3)*6
+        [[[5, '+', 3], '*', 6]]
+
+        -2--11
+        [[['-', 2], '-', ['-', 11]]]
+    """
+    ret = Forward()
+    lastExpr = baseExpr | ( lpar + ret + rpar )
+    for i,operDef in enumerate(opList):
+        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
+        termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
+        if arity == 3:
+            if opExpr is None or len(opExpr) != 2:
+                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
+            opExpr1, opExpr2 = opExpr
+        thisExpr = Forward().setName(termName)
+        if rightLeftAssoc == opAssoc.LEFT:
+            if arity == 1:
+                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
+                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        elif rightLeftAssoc == opAssoc.RIGHT:
+            if arity == 1:
+                # try to avoid LR with this extra test
+                if not isinstance(opExpr, Optional):
+                    opExpr = Optional(opExpr)
+                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
+            elif arity == 2:
+                if opExpr is not None:
+                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
+                else:
+                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
+            elif arity == 3:
+                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
+                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
+            else:
+                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
+        else:
+            raise ValueError("operator must indicate right or left associativity")
+        if pa:
+            if isinstance(pa, (tuple, list)):
+                matchExpr.setParseAction(*pa)
+            else:
+                matchExpr.setParseAction(pa)
+        thisExpr <<= ( matchExpr.setName(termName) | lastExpr )
+        lastExpr = thisExpr
+    ret <<= lastExpr
+    return ret
+
+operatorPrecedence = infixNotation
+"""(Deprecated) Former name of C{L{infixNotation}}, will be dropped in a future release."""
+
+dblQuotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"').setName("string enclosed in double quotes")
+sglQuotedString = Combine(Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("string enclosed in single quotes")
+quotedString = Combine(Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*')+'"'|
+                       Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\(?:[^x]|x[0-9a-fA-F]+)))*")+"'").setName("quotedString using single or double quotes")
+unicodeString = Combine(_L('u') + quotedString.copy()).setName("unicode string literal")
+
+def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
+    """
+    Helper method for defining nested lists enclosed in opening and closing
+    delimiters ("(" and ")" are the default).
+
+    Parameters:
+     - opener - opening character for a nested list (default=C{"("}); can also be a pyparsing expression
+     - closer - closing character for a nested list (default=C{")"}); can also be a pyparsing expression
+     - content - expression for items within the nested lists (default=C{None})
+     - ignoreExpr - expression for ignoring opening and closing delimiters (default=C{quotedString})
+
+    If an expression is not provided for the content argument, the nested
+    expression will capture all whitespace-delimited content between delimiters
+    as a list of separate values.
+
+    Use the C{ignoreExpr} argument to define expressions that may contain
+    opening or closing characters that should not be treated as opening
+    or closing characters for nesting, such as quotedString or a comment
+    expression.  Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
+    The default is L{quotedString}, but if no expressions are to be ignored,
+    then pass C{None} for this argument.
+
+    Example::
+        data_type = oneOf("void int short long char float double")
+        decl_data_type = Combine(data_type + Optional(Word('*')))
+        ident = Word(alphas+'_', alphanums+'_')
+        number = pyparsing_common.number
+        arg = Group(decl_data_type + ident)
+        LPAR,RPAR = map(Suppress, "()")
+
+        code_body = nestedExpr('{', '}', ignoreExpr=(quotedString | cStyleComment))
+
+        c_function = (decl_data_type("type") 
+                      + ident("name")
+                      + LPAR + Optional(delimitedList(arg), [])("args") + RPAR 
+                      + code_body("body"))
+        c_function.ignore(cStyleComment)
+        
+        source_code = '''
+            int is_odd(int x) { 
+                return (x%2); 
+            }
+                
+            int dec_to_hex(char hchar) { 
+                if (hchar >= '0' && hchar <= '9') { 
+                    return (ord(hchar)-ord('0')); 
+                } else { 
+                    return (10+ord(hchar)-ord('A'));
+                } 
+            }
+        '''
+        for func in c_function.searchString(source_code):
+            print("%(name)s (%(type)s) args: %(args)s" % func)
+
+    prints::
+        is_odd (int) args: [['int', 'x']]
+        dec_to_hex (int) args: [['char', 'hchar']]
+    """
+    if opener == closer:
+        raise ValueError("opening and closing strings cannot be the same")
+    if content is None:
+        if isinstance(opener,basestring) and isinstance(closer,basestring):
+            if len(opener) == 1 and len(closer)==1:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr +
+                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
+                                ).setParseAction(lambda t:t[0].strip()))
+            else:
+                if ignoreExpr is not None:
+                    content = (Combine(OneOrMore(~ignoreExpr + 
+                                    ~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+                else:
+                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
+                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
+                                ).setParseAction(lambda t:t[0].strip()))
+        else:
+            raise ValueError("opening and closing arguments must be strings if no content expression is given")
+    ret = Forward()
+    if ignoreExpr is not None:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
+    else:
+        ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
+    ret.setName('nested %s%s expression' % (opener,closer))
+    return ret
+
+def indentedBlock(blockStatementExpr, indentStack, indent=True):
+    """
+    Helper method for defining space-delimited indentation blocks, such as
+    those used to define block statements in Python source code.
+
+    Parameters:
+     - blockStatementExpr - expression defining syntax of statement that
+            is repeated within the indented block
+     - indentStack - list created by caller to manage indentation stack
+            (multiple statementWithIndentedBlock expressions within a single grammar
+            should share a common indentStack)
+     - indent - boolean indicating whether block must be indented beyond the
+            the current level; set to False for block of left-most statements
+            (default=C{True})
+
+    A valid block must contain at least one C{blockStatement}.
+
+    Example::
+        data = '''
+        def A(z):
+          A1
+          B = 100
+          G = A2
+          A2
+          A3
+        B
+        def BB(a,b,c):
+          BB1
+          def BBA():
+            bba1
+            bba2
+            bba3
+        C
+        D
+        def spam(x,y):
+             def eggs(z):
+                 pass
+        '''
+
+
+        indentStack = [1]
+        stmt = Forward()
+
+        identifier = Word(alphas, alphanums)
+        funcDecl = ("def" + identifier + Group( "(" + Optional( delimitedList(identifier) ) + ")" ) + ":")
+        func_body = indentedBlock(stmt, indentStack)
+        funcDef = Group( funcDecl + func_body )
+
+        rvalue = Forward()
+        funcCall = Group(identifier + "(" + Optional(delimitedList(rvalue)) + ")")
+        rvalue << (funcCall | identifier | Word(nums))
+        assignment = Group(identifier + "=" + rvalue)
+        stmt << ( funcDef | assignment | identifier )
+
+        module_body = OneOrMore(stmt)
+
+        parseTree = module_body.parseString(data)
+        parseTree.pprint()
+    prints::
+        [['def',
+          'A',
+          ['(', 'z', ')'],
+          ':',
+          [['A1'], [['B', '=', '100']], [['G', '=', 'A2']], ['A2'], ['A3']]],
+         'B',
+         ['def',
+          'BB',
+          ['(', 'a', 'b', 'c', ')'],
+          ':',
+          [['BB1'], [['def', 'BBA', ['(', ')'], ':', [['bba1'], ['bba2'], ['bba3']]]]]],
+         'C',
+         'D',
+         ['def',
+          'spam',
+          ['(', 'x', 'y', ')'],
+          ':',
+          [[['def', 'eggs', ['(', 'z', ')'], ':', [['pass']]]]]]] 
+    """
+    def checkPeerIndent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if curCol != indentStack[-1]:
+            if curCol > indentStack[-1]:
+                raise ParseFatalException(s,l,"illegal nesting")
+            raise ParseException(s,l,"not a peer entry")
+
+    def checkSubIndent(s,l,t):
+        curCol = col(l,s)
+        if curCol > indentStack[-1]:
+            indentStack.append( curCol )
+        else:
+            raise ParseException(s,l,"not a subentry")
+
+    def checkUnindent(s,l,t):
+        if l >= len(s): return
+        curCol = col(l,s)
+        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
+            raise ParseException(s,l,"not an unindent")
+        indentStack.pop()
+
+    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
+    INDENT = (Empty() + Empty().setParseAction(checkSubIndent)).setName('INDENT')
+    PEER   = Empty().setParseAction(checkPeerIndent).setName('')
+    UNDENT = Empty().setParseAction(checkUnindent).setName('UNINDENT')
+    if indent:
+        smExpr = Group( Optional(NL) +
+            #~ FollowedBy(blockStatementExpr) +
+            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
+    else:
+        smExpr = Group( Optional(NL) +
+            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
+    blockStatementExpr.ignore(_bslash + LineEnd())
+    return smExpr.setName('indented block')
+
+alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
+punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
+
+anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:").setName('any tag'))
+_htmlEntityMap = dict(zip("gt lt amp nbsp quot apos".split(),'><& "\''))
+commonHTMLEntity = Regex('&(?P<entity>' + '|'.join(_htmlEntityMap.keys()) +");").setName("common HTML entity")
+def replaceHTMLEntity(t):
+    """Helper parser action to replace common HTML entities with their special characters"""
+    return _htmlEntityMap.get(t.entity)
+
+# it's easy to get these comment structures wrong - they're very common, so may as well make them available
+cStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/').setName("C style comment")
+"Comment of the form C{/* ... */}"
+
+htmlComment = Regex(r"<!--[\s\S]*?-->").setName("HTML comment")
+"Comment of the form C{<!-- ... -->}"
+
+restOfLine = Regex(r".*").leaveWhitespace().setName("rest of line")
+dblSlashComment = Regex(r"//(?:\\\n|[^\n])*").setName("// comment")
+"Comment of the form C{// ... (to end of line)}"
+
+cppStyleComment = Combine(Regex(r"/\*(?:[^*]|\*(?!/))*") + '*/'| dblSlashComment).setName("C++ style comment")
+"Comment of either form C{L{cStyleComment}} or C{L{dblSlashComment}}"
+
+javaStyleComment = cppStyleComment
+"Same as C{L{cppStyleComment}}"
+
+pythonStyleComment = Regex(r"#.*").setName("Python style comment")
+"Comment of the form C{# ... (to end of line)}"
+
+_commasepitem = Combine(OneOrMore(Word(printables, excludeChars=',') +
+                                  Optional( Word(" \t") +
+                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
+commaSeparatedList = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("commaSeparatedList")
+"""(Deprecated) Predefined expression of 1 or more printable words or quoted strings, separated by commas.
+   This expression is deprecated in favor of L{pyparsing_common.comma_separated_list}."""
+
+# some other useful expressions - using lower-case class name since we are really using this as a namespace
+class pyparsing_common:
+    """
+    Here are some common low-level expressions that may be useful in jump-starting parser development:
+     - numeric forms (L{integers<integer>}, L{reals<real>}, L{scientific notation<sci_real>})
+     - common L{programming identifiers<identifier>}
+     - network addresses (L{MAC<mac_address>}, L{IPv4<ipv4_address>}, L{IPv6<ipv6_address>})
+     - ISO8601 L{dates<iso8601_date>} and L{datetime<iso8601_datetime>}
+     - L{UUID<uuid>}
+     - L{comma-separated list<comma_separated_list>}
+    Parse actions:
+     - C{L{convertToInteger}}
+     - C{L{convertToFloat}}
+     - C{L{convertToDate}}
+     - C{L{convertToDatetime}}
+     - C{L{stripHTMLTags}}
+     - C{L{upcaseTokens}}
+     - C{L{downcaseTokens}}
+
+    Example::
+        pyparsing_common.number.runTests('''
+            # any int or real number, returned as the appropriate type
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.fnumber.runTests('''
+            # any int or real number, returned as float
+            100
+            -100
+            +100
+            3.14159
+            6.02e23
+            1e-12
+            ''')
+
+        pyparsing_common.hex_integer.runTests('''
+            # hex numbers
+            100
+            FF
+            ''')
+
+        pyparsing_common.fraction.runTests('''
+            # fractions
+            1/2
+            -3/4
+            ''')
+
+        pyparsing_common.mixed_integer.runTests('''
+            # mixed fractions
+            1
+            1/2
+            -3/4
+            1-3/4
+            ''')
+
+        import uuid
+        pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+        pyparsing_common.uuid.runTests('''
+            # uuid
+            12345678-1234-5678-1234-567812345678
+            ''')
+    prints::
+        # any int or real number, returned as the appropriate type
+        100
+        [100]
+
+        -100
+        [-100]
+
+        +100
+        [100]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # any int or real number, returned as float
+        100
+        [100.0]
+
+        -100
+        [-100.0]
+
+        +100
+        [100.0]
+
+        3.14159
+        [3.14159]
+
+        6.02e23
+        [6.02e+23]
+
+        1e-12
+        [1e-12]
+
+        # hex numbers
+        100
+        [256]
+
+        FF
+        [255]
+
+        # fractions
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        # mixed fractions
+        1
+        [1]
+
+        1/2
+        [0.5]
+
+        -3/4
+        [-0.75]
+
+        1-3/4
+        [1.75]
+
+        # uuid
+        12345678-1234-5678-1234-567812345678
+        [UUID('12345678-1234-5678-1234-567812345678')]
+    """
+
+    convertToInteger = tokenMap(int)
+    """
+    Parse action for converting parsed integers to Python int
+    """
+
+    convertToFloat = tokenMap(float)
+    """
+    Parse action for converting parsed numbers to Python float
+    """
+
+    integer = Word(nums).setName("integer").setParseAction(convertToInteger)
+    """expression that parses an unsigned integer, returns an int"""
+
+    hex_integer = Word(hexnums).setName("hex integer").setParseAction(tokenMap(int,16))
+    """expression that parses a hexadecimal integer, returns an int"""
+
+    signed_integer = Regex(r'[+-]?\d+').setName("signed integer").setParseAction(convertToInteger)
+    """expression that parses an integer with optional leading sign, returns an int"""
+
+    fraction = (signed_integer().setParseAction(convertToFloat) + '/' + signed_integer().setParseAction(convertToFloat)).setName("fraction")
+    """fractional expression of an integer divided by an integer, returns a float"""
+    fraction.addParseAction(lambda t: t[0]/t[-1])
+
+    mixed_integer = (fraction | signed_integer + Optional(Optional('-').suppress() + fraction)).setName("fraction or mixed integer-fraction")
+    """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
+    mixed_integer.addParseAction(sum)
+
+    real = Regex(r'[+-]?\d+\.\d*').setName("real number").setParseAction(convertToFloat)
+    """expression that parses a floating point number and returns a float"""
+
+    sci_real = Regex(r'[+-]?\d+([eE][+-]?\d+|\.\d*([eE][+-]?\d+)?)').setName("real number with scientific notation").setParseAction(convertToFloat)
+    """expression that parses a floating point number with optional scientific notation and returns a float"""
+
+    # streamlining this expression makes the docs nicer-looking
+    number = (sci_real | real | signed_integer).streamline()
+    """any numeric expression, returns the corresponding Python type"""
+
+    fnumber = Regex(r'[+-]?\d+\.?\d*([eE][+-]?\d+)?').setName("fnumber").setParseAction(convertToFloat)
+    """any int or real number, returned as float"""
+    
+    identifier = Word(alphas+'_', alphanums+'_').setName("identifier")
+    """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
+    
+    ipv4_address = Regex(r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}').setName("IPv4 address")
+    "IPv4 address (C{0.0.0.0 - 255.255.255.255})"
+
+    _ipv6_part = Regex(r'[0-9a-fA-F]{1,4}').setName("hex_integer")
+    _full_ipv6_address = (_ipv6_part + (':' + _ipv6_part)*7).setName("full IPv6 address")
+    _short_ipv6_address = (Optional(_ipv6_part + (':' + _ipv6_part)*(0,6)) + "::" + Optional(_ipv6_part + (':' + _ipv6_part)*(0,6))).setName("short IPv6 address")
+    _short_ipv6_address.addCondition(lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8)
+    _mixed_ipv6_address = ("::ffff:" + ipv4_address).setName("mixed IPv6 address")
+    ipv6_address = Combine((_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).setName("IPv6 address")).setName("IPv6 address")
+    "IPv6 address (long, short, or mixed form)"
+    
+    mac_address = Regex(r'[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}').setName("MAC address")
+    "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
+
+    @staticmethod
+    def convertToDate(fmt="%Y-%m-%d"):
+        """
+        Helper to create a parse action for converting parsed date string to Python datetime.date
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%d"})
+
+        Example::
+            date_expr = pyparsing_common.iso8601_date.copy()
+            date_expr.setParseAction(pyparsing_common.convertToDate())
+            print(date_expr.parseString("1999-12-31"))
+        prints::
+            [datetime.date(1999, 12, 31)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt).date()
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    @staticmethod
+    def convertToDatetime(fmt="%Y-%m-%dT%H:%M:%S.%f"):
+        """
+        Helper to create a parse action for converting parsed datetime string to Python datetime.datetime
+
+        Params -
+         - fmt - format to be passed to datetime.strptime (default=C{"%Y-%m-%dT%H:%M:%S.%f"})
+
+        Example::
+            dt_expr = pyparsing_common.iso8601_datetime.copy()
+            dt_expr.setParseAction(pyparsing_common.convertToDatetime())
+            print(dt_expr.parseString("1999-12-31T23:59:59.999"))
+        prints::
+            [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
+        """
+        def cvt_fn(s,l,t):
+            try:
+                return datetime.strptime(t[0], fmt)
+            except ValueError as ve:
+                raise ParseException(s, l, str(ve))
+        return cvt_fn
+
+    iso8601_date = Regex(r'(?P<year>\d{4})(?:-(?P<month>\d\d)(?:-(?P<day>\d\d))?)?').setName("ISO8601 date")
+    "ISO8601 date (C{yyyy-mm-dd})"
+
+    iso8601_datetime = Regex(r'(?P<year>\d{4})-(?P<month>\d\d)-(?P<day>\d\d)[T ](?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d(\.\d*)?)?)?(?P<tz>Z|[+-]\d\d:?\d\d)?').setName("ISO8601 datetime")
+    "ISO8601 datetime (C{yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)}) - trailing seconds, milliseconds, and timezone optional; accepts separating C{'T'} or C{' '}"
+
+    uuid = Regex(r'[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}').setName("UUID")
+    "UUID (C{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx})"
+
+    _html_stripper = anyOpenTag.suppress() | anyCloseTag.suppress()
+    @staticmethod
+    def stripHTMLTags(s, l, tokens):
+        """
+        Parse action to remove HTML tags from web page HTML source
+
+        Example::
+            # strip HTML links from normal text 
+            text = '<td>More info at the <a href="http://pyparsing.wikispaces.com">pyparsing</a> wiki page</td>'
+            td,td_end = makeHTMLTags("TD")
+            table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
+            
+            print(table_text.parseString(text).body) # -> 'More info at the pyparsing wiki page'
+        """
+        return pyparsing_common._html_stripper.transformString(tokens[0])
+
+    _commasepitem = Combine(OneOrMore(~Literal(",") + ~LineEnd() + Word(printables, excludeChars=',') 
+                                        + Optional( White(" \t") ) ) ).streamline().setName("commaItem")
+    comma_separated_list = delimitedList( Optional( quotedString.copy() | _commasepitem, default="") ).setName("comma separated list")
+    """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
+
+    upcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).upper()))
+    """Parse action to convert tokens to upper case."""
+
+    downcaseTokens = staticmethod(tokenMap(lambda t: _ustr(t).lower()))
+    """Parse action to convert tokens to lower case."""
+
+
+if __name__ == "__main__":
+
+    selectToken    = CaselessLiteral("select")
+    fromToken      = CaselessLiteral("from")
+
+    ident          = Word(alphas, alphanums + "_$")
+
+    columnName     = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    columnNameList = Group(delimitedList(columnName)).setName("columns")
+    columnSpec     = ('*' | columnNameList)
+
+    tableName      = delimitedList(ident, ".", combine=True).setParseAction(upcaseTokens)
+    tableNameList  = Group(delimitedList(tableName)).setName("tables")
+    
+    simpleSQL      = selectToken("command") + columnSpec("columns") + fromToken + tableNameList("tables")
+
+    # demo runTests method, including embedded comments in test string
+    simpleSQL.runTests("""
+        # '*' as column list and dotted table name
+        select * from SYS.XYZZY
+
+        # caseless match on "SELECT", and casts back to "select"
+        SELECT * from XYZZY, ABC
+
+        # list of column names, and mixed case SELECT keyword
+        Select AA,BB,CC from Sys.dual
+
+        # multiple tables
+        Select A, B, C from Sys.dual, Table2
+
+        # invalid SELECT keyword - should fail
+        Xelect A, B, C from Sys.dual
+
+        # incomplete command - should fail
+        Select
+
+        # invalid column name - should fail
+        Select ^^^ frox Sys.dual
+
+        """)
+
+    pyparsing_common.number.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    # any int or real number, returned as float
+    pyparsing_common.fnumber.runTests("""
+        100
+        -100
+        +100
+        3.14159
+        6.02e23
+        1e-12
+        """)
+
+    pyparsing_common.hex_integer.runTests("""
+        100
+        FF
+        """)
+
+    import uuid
+    pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
+    pyparsing_common.uuid.runTests("""
+        12345678-1234-5678-1234-567812345678
+        """)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/six.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/six.py
new file mode 100644
index 0000000000000000000000000000000000000000..190c0239cd7d7af82a6e0cbc8d68053fa2e3dfaf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/six.py
@@ -0,0 +1,868 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2015 Benjamin Peterson
+#
+# 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.
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.10.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        if value is None:
+            value = tp()
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+if sys.version_info[:2] == (3, 2):
+    exec_("""def raise_from(value, from_value):
+    if from_value is None:
+        raise value
+    raise value from from_value
+""")
+elif sys.version_info[:2] > (3, 2):
+    exec_("""def raise_from(value, from_value):
+    raise value from from_value
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        def wrapper(f):
+            f = functools.wraps(wrapped, assigned, updated)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/extern/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/extern/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1eb9e998f8e117c82c176bc83ab1d350c729cd7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/extern/__init__.py
@@ -0,0 +1,73 @@
+import sys
+
+
+class VendorImporter:
+    """
+    A PEP 302 meta path importer for finding optionally-vendored
+    or otherwise naturally-installed packages from root_name.
+    """
+
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
+        self.root_name = root_name
+        self.vendored_names = set(vendored_names)
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
+
+    @property
+    def search_path(self):
+        """
+        Search first the vendor package then as a natural package.
+        """
+        yield self.vendor_pkg + '.'
+        yield ''
+
+    def find_module(self, fullname, path=None):
+        """
+        Return self when fullname starts with root_name and the
+        target module is one vendored through this importer.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        if root:
+            return
+        if not any(map(target.startswith, self.vendored_names)):
+            return
+        return self
+
+    def load_module(self, fullname):
+        """
+        Iterate over the search path to locate and load fullname.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        for prefix in self.search_path:
+            try:
+                extant = prefix + target
+                __import__(extant)
+                mod = sys.modules[extant]
+                sys.modules[fullname] = mod
+                # mysterious hack:
+                # Remove the reference to the extant package/module
+                # on later Python versions to cause relative imports
+                # in the vendor package to resolve the same modules
+                # as those going through this importer.
+                if prefix and sys.version_info > (3, 3):
+                    del sys.modules[extant]
+                return mod
+            except ImportError:
+                pass
+        else:
+            raise ImportError(
+                "The '{target}' package is required; "
+                "normally this is bundled with this package so if you get "
+                "this warning, consult the packager of your "
+                "distribution.".format(**locals())
+            )
+
+    def install(self):
+        """
+        Install this importer into sys.meta_path if not already present.
+        """
+        if self not in sys.meta_path:
+            sys.meta_path.append(self)
+
+
+names = 'packaging', 'pyparsing', 'six', 'appdirs'
+VendorImporter(__name__, names).install()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..86c714ad1aed3b1b511d90c1e1ce6cb22d662ec3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/__init__.py
@@ -0,0 +1 @@
+""" high-level sub-process handling """
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/forkedfunc.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/forkedfunc.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c285306884bf2f0310d8b4f94a4ae2f772fe04f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/forkedfunc.py
@@ -0,0 +1,120 @@
+
+"""
+    ForkedFunc provides a way to run a function in a forked process
+    and get at its return value, stdout and stderr output as well
+    as signals and exitstatusus.
+"""
+
+import py
+import os
+import sys
+import marshal
+
+
+def get_unbuffered_io(fd, filename):
+    f = open(str(filename), "w")
+    if fd != f.fileno():
+        os.dup2(f.fileno(), fd)
+    class AutoFlush:
+        def write(self, data):
+            f.write(data)
+            f.flush()
+        def __getattr__(self, name):
+            return getattr(f, name)
+    return AutoFlush()
+
+
+class ForkedFunc:
+    EXITSTATUS_EXCEPTION = 3
+
+
+    def __init__(self, fun, args=None, kwargs=None, nice_level=0,
+                 child_on_start=None, child_on_exit=None):
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = {}
+        self.fun = fun
+        self.args = args
+        self.kwargs = kwargs
+        self.tempdir = tempdir = py.path.local.mkdtemp()
+        self.RETVAL = tempdir.ensure('retval')
+        self.STDOUT = tempdir.ensure('stdout')
+        self.STDERR = tempdir.ensure('stderr')
+
+        pid = os.fork()
+        if pid:  # in parent process
+            self.pid = pid
+        else:  # in child process
+            self.pid = None
+            self._child(nice_level, child_on_start, child_on_exit)
+
+    def _child(self, nice_level, child_on_start, child_on_exit):
+        # right now we need to call a function, but first we need to
+        # map all IO that might happen
+        sys.stdout = stdout = get_unbuffered_io(1, self.STDOUT)
+        sys.stderr = stderr = get_unbuffered_io(2, self.STDERR)
+        retvalf = self.RETVAL.open("wb")
+        EXITSTATUS = 0
+        try:
+            if nice_level:
+                os.nice(nice_level)
+            try:
+                if child_on_start is not None:
+                    child_on_start()
+                retval = self.fun(*self.args, **self.kwargs)
+                retvalf.write(marshal.dumps(retval))
+                if child_on_exit is not None:
+                    child_on_exit()
+            except:
+                excinfo = py.code.ExceptionInfo()
+                stderr.write(str(excinfo._getreprcrash()))
+                EXITSTATUS = self.EXITSTATUS_EXCEPTION
+        finally:
+            stdout.close()
+            stderr.close()
+            retvalf.close()
+        os.close(1)
+        os.close(2)
+        os._exit(EXITSTATUS)
+
+    def waitfinish(self, waiter=os.waitpid):
+        pid, systemstatus = waiter(self.pid, 0)
+        if systemstatus:
+            if os.WIFSIGNALED(systemstatus):
+                exitstatus = os.WTERMSIG(systemstatus) + 128
+            else:
+                exitstatus = os.WEXITSTATUS(systemstatus)
+        else:
+            exitstatus = 0
+        signal = systemstatus & 0x7f
+        if not exitstatus and not signal:
+            retval = self.RETVAL.open('rb')
+            try:
+                retval_data = retval.read()
+            finally:
+                retval.close()
+            retval = marshal.loads(retval_data)
+        else:
+            retval = None
+        stdout = self.STDOUT.read()
+        stderr = self.STDERR.read()
+        self._removetemp()
+        return Result(exitstatus, signal, retval, stdout, stderr)
+
+    def _removetemp(self):
+        if self.tempdir.check():
+            self.tempdir.remove()
+
+    def __del__(self):
+        if self.pid is not None:  # only clean up in main process
+            self._removetemp()
+
+
+class Result(object):
+    def __init__(self, exitstatus, signal, retval, stdout, stderr):
+        self.exitstatus = exitstatus
+        self.signal = signal
+        self.retval = retval
+        self.out = stdout
+        self.err = stderr
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/killproc.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/killproc.py
new file mode 100644
index 0000000000000000000000000000000000000000..18e8310b5f6caaf884473ba11c4c4d3b6f78c7d3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_process/killproc.py
@@ -0,0 +1,23 @@
+import py
+import os, sys
+
+if sys.platform == "win32" or getattr(os, '_name', '') == 'nt':
+    try:
+        import ctypes
+    except ImportError:
+        def dokill(pid):
+            py.process.cmdexec("taskkill /F /PID %d" %(pid,))
+    else:
+        def dokill(pid):
+            PROCESS_TERMINATE = 1
+            handle = ctypes.windll.kernel32.OpenProcess(
+                        PROCESS_TERMINATE, False, pid)
+            ctypes.windll.kernel32.TerminateProcess(handle, -1)
+            ctypes.windll.kernel32.CloseHandle(handle)
+else:
+    def dokill(pid):
+        os.kill(pid, 15)
+
+def kill(pid):
+    """ kill process by id. """
+    dokill(pid)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/apipkg.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/apipkg.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d56e0bcbae477c68e17a8282a126a2a28c78756
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/apipkg.py
@@ -0,0 +1,205 @@
+"""
+apipkg: control the exported namespace of a python package.
+
+see http://pypi.python.org/pypi/apipkg
+
+(c) holger krekel, 2009 - MIT license
+"""
+import os
+import sys
+from types import ModuleType
+
+
+__version__ = '1.4'
+
+
+def _py_abspath(path):
+    """
+    special version of abspath
+    that will leave paths from jython jars alone
+    """
+    if path.startswith('__pyclasspath__'):
+
+        return path
+    else:
+        return os.path.abspath(path)
+
+
+def distribution_version(name):
+    """try to get the version of the named distribution,
+    returs None on failure"""
+    from pkg_resources import get_distribution, DistributionNotFound
+    try:
+        dist = get_distribution(name)
+    except DistributionNotFound:
+        pass
+    else:
+        return dist.version
+
+
+def initpkg(pkgname, exportdefs, attr=dict(), eager=False):
+    """ initialize given package from the export definitions. """
+    oldmod = sys.modules.get(pkgname)
+    d = {}
+    f = getattr(oldmod, '__file__', None)
+    if f:
+        f = _py_abspath(f)
+    d['__file__'] = f
+    if hasattr(oldmod, '__version__'):
+        d['__version__'] = oldmod.__version__
+    if hasattr(oldmod, '__loader__'):
+        d['__loader__'] = oldmod.__loader__
+    if hasattr(oldmod, '__path__'):
+        d['__path__'] = [_py_abspath(p) for p in oldmod.__path__]
+    if '__doc__' not in exportdefs and getattr(oldmod, '__doc__', None):
+        d['__doc__'] = oldmod.__doc__
+    d.update(attr)
+    if hasattr(oldmod, "__dict__"):
+        oldmod.__dict__.update(d)
+    mod = ApiModule(pkgname, exportdefs, implprefix=pkgname, attr=d)
+    sys.modules[pkgname] = mod
+    # eagerload in bypthon to avoid their monkeypatching breaking packages
+    if 'bpython' in sys.modules or eager:
+        for module in sys.modules.values():
+            if isinstance(module, ApiModule):
+                module.__dict__
+
+
+def importobj(modpath, attrname):
+    module = __import__(modpath, None, None, ['__doc__'])
+    if not attrname:
+        return module
+
+    retval = module
+    names = attrname.split(".")
+    for x in names:
+        retval = getattr(retval, x)
+    return retval
+
+
+class ApiModule(ModuleType):
+    def __docget(self):
+        try:
+            return self.__doc
+        except AttributeError:
+            if '__doc__' in self.__map__:
+                return self.__makeattr('__doc__')
+
+    def __docset(self, value):
+        self.__doc = value
+    __doc__ = property(__docget, __docset)
+
+    def __init__(self, name, importspec, implprefix=None, attr=None):
+        self.__name__ = name
+        self.__all__ = [x for x in importspec if x != '__onfirstaccess__']
+        self.__map__ = {}
+        self.__implprefix__ = implprefix or name
+        if attr:
+            for name, val in attr.items():
+                # print "setting", self.__name__, name, val
+                setattr(self, name, val)
+        for name, importspec in importspec.items():
+            if isinstance(importspec, dict):
+                subname = '%s.%s' % (self.__name__, name)
+                apimod = ApiModule(subname, importspec, implprefix)
+                sys.modules[subname] = apimod
+                setattr(self, name, apimod)
+            else:
+                parts = importspec.split(':')
+                modpath = parts.pop(0)
+                attrname = parts and parts[0] or ""
+                if modpath[0] == '.':
+                    modpath = implprefix + modpath
+
+                if not attrname:
+                    subname = '%s.%s' % (self.__name__, name)
+                    apimod = AliasModule(subname, modpath)
+                    sys.modules[subname] = apimod
+                    if '.' not in name:
+                        setattr(self, name, apimod)
+                else:
+                    self.__map__[name] = (modpath, attrname)
+
+    def __repr__(self):
+        l = []
+        if hasattr(self, '__version__'):
+            l.append("version=" + repr(self.__version__))
+        if hasattr(self, '__file__'):
+            l.append('from ' + repr(self.__file__))
+        if l:
+            return '<ApiModule %r %s>' % (self.__name__, " ".join(l))
+        return '<ApiModule %r>' % (self.__name__,)
+
+    def __makeattr(self, name):
+        """lazily compute value for name or raise AttributeError if unknown."""
+        # print "makeattr", self.__name__, name
+        target = None
+        if '__onfirstaccess__' in self.__map__:
+            target = self.__map__.pop('__onfirstaccess__')
+            importobj(*target)()
+        try:
+            modpath, attrname = self.__map__[name]
+        except KeyError:
+            if target is not None and name != '__onfirstaccess__':
+                # retry, onfirstaccess might have set attrs
+                return getattr(self, name)
+            raise AttributeError(name)
+        else:
+            result = importobj(modpath, attrname)
+            setattr(self, name, result)
+            try:
+                del self.__map__[name]
+            except KeyError:
+                pass  # in a recursive-import situation a double-del can happen
+            return result
+
+    __getattr__ = __makeattr
+
+    @property
+    def __dict__(self):
+        # force all the content of the module
+        # to be loaded when __dict__ is read
+        dictdescr = ModuleType.__dict__['__dict__']
+        dict = dictdescr.__get__(self)
+        if dict is not None:
+            hasattr(self, 'some')
+            for name in self.__all__:
+                try:
+                    self.__makeattr(name)
+                except AttributeError:
+                    pass
+        return dict
+
+
+def AliasModule(modname, modpath, attrname=None):
+    mod = []
+
+    def getmod():
+        if not mod:
+            x = importobj(modpath, None)
+            if attrname is not None:
+                x = getattr(x, attrname)
+            mod.append(x)
+        return mod[0]
+
+    class AliasModule(ModuleType):
+
+        def __repr__(self):
+            x = modpath
+            if attrname:
+                x += "." + attrname
+            return '<AliasModule %r for %r>' % (modname, x)
+
+        def __getattribute__(self, name):
+            try:
+                return getattr(getmod(), name)
+            except ImportError:
+                return None
+
+        def __setattr__(self, name, value):
+            setattr(getmod(), name, value)
+
+        def __delattr__(self, name):
+            delattr(getmod(), name)
+
+    return AliasModule(str(modname))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/iniconfig.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/iniconfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ad9eaf868b073bb33aac5ee9814e4efe2e19da1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/py/_vendored_packages/iniconfig.py
@@ -0,0 +1,165 @@
+""" brain-dead simple parser for ini-style files.
+(C) Ronny Pfannschmidt, Holger Krekel -- MIT licensed
+"""
+__all__ = ['IniConfig', 'ParseError']
+
+COMMENTCHARS = "#;"
+
+
+class ParseError(Exception):
+    def __init__(self, path, lineno, msg):
+        Exception.__init__(self, path, lineno, msg)
+        self.path = path
+        self.lineno = lineno
+        self.msg = msg
+
+    def __str__(self):
+        return "%s:%s: %s" % (self.path, self.lineno+1, self.msg)
+
+
+class SectionWrapper(object):
+    def __init__(self, config, name):
+        self.config = config
+        self.name = name
+
+    def lineof(self, name):
+        return self.config.lineof(self.name, name)
+
+    def get(self, key, default=None, convert=str):
+        return self.config.get(self.name, key,
+                               convert=convert, default=default)
+
+    def __getitem__(self, key):
+        return self.config.sections[self.name][key]
+
+    def __iter__(self):
+        section = self.config.sections.get(self.name, [])
+
+        def lineof(key):
+            return self.config.lineof(self.name, key)
+        for name in sorted(section, key=lineof):
+            yield name
+
+    def items(self):
+        for name in self:
+            yield name, self[name]
+
+
+class IniConfig(object):
+    def __init__(self, path, data=None):
+        self.path = str(path)  # convenience
+        if data is None:
+            f = open(self.path)
+            try:
+                tokens = self._parse(iter(f))
+            finally:
+                f.close()
+        else:
+            tokens = self._parse(data.splitlines(True))
+
+        self._sources = {}
+        self.sections = {}
+
+        for lineno, section, name, value in tokens:
+            if section is None:
+                self._raise(lineno, 'no section header defined')
+            self._sources[section, name] = lineno
+            if name is None:
+                if section in self.sections:
+                    self._raise(lineno, 'duplicate section %r' % (section, ))
+                self.sections[section] = {}
+            else:
+                if name in self.sections[section]:
+                    self._raise(lineno, 'duplicate name %r' % (name, ))
+                self.sections[section][name] = value
+
+    def _raise(self, lineno, msg):
+        raise ParseError(self.path, lineno, msg)
+
+    def _parse(self, line_iter):
+        result = []
+        section = None
+        for lineno, line in enumerate(line_iter):
+            name, data = self._parseline(line, lineno)
+            # new value
+            if name is not None and data is not None:
+                result.append((lineno, section, name, data))
+            # new section
+            elif name is not None and data is None:
+                if not name:
+                    self._raise(lineno, 'empty section name')
+                section = name
+                result.append((lineno, section, None, None))
+            # continuation
+            elif name is None and data is not None:
+                if not result:
+                    self._raise(lineno, 'unexpected value continuation')
+                last = result.pop()
+                last_name, last_data = last[-2:]
+                if last_name is None:
+                    self._raise(lineno, 'unexpected value continuation')
+
+                if last_data:
+                    data = '%s\n%s' % (last_data, data)
+                result.append(last[:-1] + (data,))
+        return result
+
+    def _parseline(self, line, lineno):
+        # blank lines
+        if iscommentline(line):
+            line = ""
+        else:
+            line = line.rstrip()
+        if not line:
+            return None, None
+        # section
+        if line[0] == '[':
+            realline = line
+            for c in COMMENTCHARS:
+                line = line.split(c)[0].rstrip()
+            if line[-1] == "]":
+                return line[1:-1], None
+            return None, realline.strip()
+        # value
+        elif not line[0].isspace():
+            try:
+                name, value = line.split('=', 1)
+                if ":" in name:
+                    raise ValueError()
+            except ValueError:
+                try:
+                    name, value = line.split(":", 1)
+                except ValueError:
+                    self._raise(lineno, 'unexpected line: %r' % line)
+            return name.strip(), value.strip()
+        # continuation
+        else:
+            return None, line.strip()
+
+    def lineof(self, section, name=None):
+        lineno = self._sources.get((section, name))
+        if lineno is not None:
+            return lineno + 1
+
+    def get(self, section, name, default=None, convert=str):
+        try:
+            return convert(self.sections[section][name])
+        except KeyError:
+            return default
+
+    def __getitem__(self, name):
+        if name not in self.sections:
+            raise KeyError(name)
+        return SectionWrapper(self, name)
+
+    def __iter__(self):
+        for name in sorted(self.sections, key=self.lineof):
+            yield SectionWrapper(self, name)
+
+    def __contains__(self, arg):
+        return arg in self.sections
+
+
+def iscommentline(line):
+    c = line.lstrip()[:1]
+    return c in COMMENTCHARS
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Buenos_Aires b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Buenos_Aires
new file mode 100644
index 0000000000000000000000000000000000000000..260f86a9180677d86fc3280b06f01d6a6cd91c94
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Buenos_Aires differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belfast b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belfast
new file mode 100644
index 0000000000000000000000000000000000000000..ac02a81440f47a67b9f01d3fbcdb085266d20894
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belfast differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belgrade b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belgrade
new file mode 100644
index 0000000000000000000000000000000000000000..27de456f16ab549627b284a39e2265cbdb4ad8e9
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Belgrade differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Berlin b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Berlin
new file mode 100644
index 0000000000000000000000000000000000000000..7f6d958f8630cba512d8e58ca8edfbd516291522
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Berlin differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bratislava b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bratislava
new file mode 100644
index 0000000000000000000000000000000000000000..ce8f433ece44f0b96b18d3b5780730e7f9cad9f5
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bratislava differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Brussels b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Brussels
new file mode 100644
index 0000000000000000000000000000000000000000..9613c9812c7a5a4e2401f65d630d6d5233164f68
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Brussels differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bucharest b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bucharest
new file mode 100644
index 0000000000000000000000000000000000000000..4303b903e5e007484c0d8e1eea43a35e9b53f38b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Bucharest differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Budapest b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Budapest
new file mode 100644
index 0000000000000000000000000000000000000000..6b94a4f3124658a723d3b189ad21b7c4f5baa3d4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Budapest differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Busingen b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Busingen
new file mode 100644
index 0000000000000000000000000000000000000000..ad6cf59281a1046d9dcd045fda521585e3e33e06
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Busingen differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Chisinau b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Chisinau
new file mode 100644
index 0000000000000000000000000000000000000000..5ee23fe0e59f044598675db44d53c20590b88934
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Chisinau differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Copenhagen b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Copenhagen
new file mode 100644
index 0000000000000000000000000000000000000000..776be6e4a6d5a054152135a1ad149576052f49a1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Copenhagen differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Honolulu b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Honolulu
new file mode 100644
index 0000000000000000000000000000000000000000..c7cd060159bd22fc5e6f10ac5a2089afb2c19c6a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Honolulu differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Johnston b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Johnston
new file mode 100644
index 0000000000000000000000000000000000000000..c7cd060159bd22fc5e6f10ac5a2089afb2c19c6a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Johnston differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kiritimati b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kiritimati
new file mode 100644
index 0000000000000000000000000000000000000000..7cae0cb7562e5c0f9fa46913b71a5c3628c01bbf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kiritimati differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kosrae b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kosrae
new file mode 100644
index 0000000000000000000000000000000000000000..a584aae5eb8187f88600e97b6d6c764245a37e65
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kosrae differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kwajalein b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kwajalein
new file mode 100644
index 0000000000000000000000000000000000000000..1a7975fad7f7e96f7101eb3c64c9b420eeebb621
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Kwajalein differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Majuro b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Majuro
new file mode 100644
index 0000000000000000000000000000000000000000..9ef8374de4fa73cd2a3359d3c3886b11643a7146
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Majuro differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Marquesas b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Marquesas
new file mode 100644
index 0000000000000000000000000000000000000000..74d6792bf6fcb791bfc0af1f827737f612abef67
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Marquesas differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Midway b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Midway
new file mode 100644
index 0000000000000000000000000000000000000000..cb56709a77dedb471150f4907771bf38f1879ba4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Midway differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Indiana-Starke b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Indiana-Starke
new file mode 100644
index 0000000000000000000000000000000000000000..fcd408d74df43310a9a85c475f83d545f6d75911
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Indiana-Starke differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Michigan b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Michigan
new file mode 100644
index 0000000000000000000000000000000000000000..5e0226057ac5e154901b0debb90547c096f9083a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Michigan differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Mountain b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Mountain
new file mode 100644
index 0000000000000000000000000000000000000000..5fbe26b1d93d1acb2561c390c1e097d07f1a262e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Mountain differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Pacific b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Pacific
new file mode 100644
index 0000000000000000000000000000000000000000..9dad4f4c75b373635ccbe634798f8d9e587e36c1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Pacific differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Samoa b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Samoa
new file mode 100644
index 0000000000000000000000000000000000000000..cb56709a77dedb471150f4907771bf38f1879ba4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Samoa differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/014c99933721e504c420b5c525973557 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/014c99933721e504c420b5c525973557
new file mode 100644
index 0000000000000000000000000000000000000000..72a8963a561c2358782cd5895ad696a354e6c30f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/014c99933721e504c420b5c525973557 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/01505266f3956a7e0dad91130c11bfdf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/01505266f3956a7e0dad91130c11bfdf
new file mode 100644
index 0000000000000000000000000000000000000000..de15eca893d26a8e0a0d08134b9c5676e41c1ddf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/01505266f3956a7e0dad91130c11bfdf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/015274da90af29855178c7dfbfa61468 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/015274da90af29855178c7dfbfa61468
new file mode 100644
index 0000000000000000000000000000000000000000..91a0ee06d3d25c4f224e85ef9f153bf2c492e9c2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/01/015274da90af29855178c7dfbfa61468 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/022a94400526eb5f238882188c711693 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/022a94400526eb5f238882188c711693
new file mode 100644
index 0000000000000000000000000000000000000000..b22c7623c13e269fb8733435b81506d4c1221312
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/022a94400526eb5f238882188c711693 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02330106fff586f2ab92b09b8198a815 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02330106fff586f2ab92b09b8198a815
new file mode 100644
index 0000000000000000000000000000000000000000..6c9b0f313ba023c9d4811c56a4cacd6f1afe34df
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02330106fff586f2ab92b09b8198a815 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02452f370dbeec0778369275c775bc9f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02452f370dbeec0778369275c775bc9f
new file mode 100644
index 0000000000000000000000000000000000000000..63a4af024e3cd619dc3f9a2d4667c909ac6510d1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/02/02452f370dbeec0778369275c775bc9f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/0332d6fd987401b308607a0fa60f7c5c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/0332d6fd987401b308607a0fa60f7c5c
new file mode 100644
index 0000000000000000000000000000000000000000..35f6a01cc11017dc91dbec17e501c2fbaaefda2d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/0332d6fd987401b308607a0fa60f7c5c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03500df05d8a3605a7e14e3043f54a41 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03500df05d8a3605a7e14e3043f54a41
new file mode 100644
index 0000000000000000000000000000000000000000..461637aeb55e27683f56f8bfb90df066f210dc1a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03500df05d8a3605a7e14e3043f54a41 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03523f21d4a45001664dddc6b3be1dd1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03523f21d4a45001664dddc6b3be1dd1
new file mode 100644
index 0000000000000000000000000000000000000000..3d5c926ceb6fe419d9e8592b9a97623695f4a07a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/03/03523f21d4a45001664dddc6b3be1dd1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0580bef82d3e6ede08210376fc288705 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0580bef82d3e6ede08210376fc288705
new file mode 100644
index 0000000000000000000000000000000000000000..891d48b84797cdb05ce41fc8e41d081a542c87ae
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/0580bef82d3e6ede08210376fc288705 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05913b3c20ba843bb3dd658d6cfcf8e8 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05913b3c20ba843bb3dd658d6cfcf8e8
new file mode 100644
index 0000000000000000000000000000000000000000..17cc98297d85dcd971b913d947bbb9656a87fe9b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05913b3c20ba843bb3dd658d6cfcf8e8 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05a5eeae018f568bb1765e8d10dde4d6 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05a5eeae018f568bb1765e8d10dde4d6
new file mode 100644
index 0000000000000000000000000000000000000000..c45681f660fffabf3f4b9a43e807864d8ed52ce9
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05a5eeae018f568bb1765e8d10dde4d6 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05aedffb105b032ab7dc81364ddca29d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05aedffb105b032ab7dc81364ddca29d
new file mode 100644
index 0000000000000000000000000000000000000000..739b87e99be422171fcfb2af79866362e907c1b1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05aedffb105b032ab7dc81364ddca29d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05ddbe61eec15e78d5858fc70d776838 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05ddbe61eec15e78d5858fc70d776838
new file mode 100644
index 0000000000000000000000000000000000000000..8ba7ddecd21965e95d9b411793255567a4a8be50
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/05/05ddbe61eec15e78d5858fc70d776838 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/06076298fed870bbc68357e1b6e8ebca b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/06076298fed870bbc68357e1b6e8ebca
new file mode 100644
index 0000000000000000000000000000000000000000..e7743d30a92ab5ec0d6487e070a08ed664e13b8f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/06076298fed870bbc68357e1b6e8ebca differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/060a479de4d7e5b214e41ea2c5a46187 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/060a479de4d7e5b214e41ea2c5a46187
new file mode 100644
index 0000000000000000000000000000000000000000..e27f69fc023aca2d5d2e09a150d09acd47fb96ad
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/06/060a479de4d7e5b214e41ea2c5a46187 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/077271962ec145a59b3bb6f27b672392 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/077271962ec145a59b3bb6f27b672392
new file mode 100644
index 0000000000000000000000000000000000000000..0096cf8e768d87a33c4cc2dabc5e8f2cf4ddf946
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/077271962ec145a59b3bb6f27b672392 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07ed1cd0cf18f16ad7cc63529cb4c56e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07ed1cd0cf18f16ad7cc63529cb4c56e
new file mode 100644
index 0000000000000000000000000000000000000000..f2800dd94fb0d6c2be3e1b0b3e52c72686ba0466
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07ed1cd0cf18f16ad7cc63529cb4c56e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07fecd51d9453e1a57040fd242938475 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07fecd51d9453e1a57040fd242938475
new file mode 100644
index 0000000000000000000000000000000000000000..2dba1ae981d80c8e7dda14df3dcf1a966a4ae00b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/07/07fecd51d9453e1a57040fd242938475 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/0817cd4e940db909893531fc9cc44397 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/0817cd4e940db909893531fc9cc44397
new file mode 100644
index 0000000000000000000000000000000000000000..51fd6d8344c12f4b0b3f4ce00143fbedc69c54f7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/0817cd4e940db909893531fc9cc44397 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/082dbe051f1d09ffb79105b41e270057 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/082dbe051f1d09ffb79105b41e270057
new file mode 100644
index 0000000000000000000000000000000000000000..dca7c388d6e6836d963b8f8a421295a05d4b0c99
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/082dbe051f1d09ffb79105b41e270057 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/084940fdb89de073e6390cb86c9800f4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/084940fdb89de073e6390cb86c9800f4
new file mode 100644
index 0000000000000000000000000000000000000000..9a924745a9c61f022888c80a386921dcb0ed721e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/08/084940fdb89de073e6390cb86c9800f4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/0965053f5c66259cc65d91ec1b992669 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/0965053f5c66259cc65d91ec1b992669
new file mode 100644
index 0000000000000000000000000000000000000000..f18402449336a161b77b47ba20dcd5ce3322d49a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/0965053f5c66259cc65d91ec1b992669 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09a040329601d60518e98baa06bcdf0c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09a040329601d60518e98baa06bcdf0c
new file mode 100644
index 0000000000000000000000000000000000000000..d0f196a2424aa268017094b9e18204270f2a1016
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09a040329601d60518e98baa06bcdf0c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09ff0459e1eebef0161b499302fd43bb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09ff0459e1eebef0161b499302fd43bb
new file mode 100644
index 0000000000000000000000000000000000000000..8fbc65bb6f65f577decaadf2b4ed86f0320f3f62
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/09/09ff0459e1eebef0161b499302fd43bb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a0ed1b8e36ffcdd342b98c3301364b0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a0ed1b8e36ffcdd342b98c3301364b0
new file mode 100644
index 0000000000000000000000000000000000000000..3e5f0852e9c6d7789ef4587084bcc2873c6cecb0
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a0ed1b8e36ffcdd342b98c3301364b0 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a2ba527e6a852a9f283d18284a5e885 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a2ba527e6a852a9f283d18284a5e885
new file mode 100644
index 0000000000000000000000000000000000000000..bc003a92ea7101a0db6fdafda17134177dfdfd0f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a2ba527e6a852a9f283d18284a5e885 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a658ef3d62485c1255e0d9ae9afaa87 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a658ef3d62485c1255e0d9ae9afaa87
new file mode 100644
index 0000000000000000000000000000000000000000..0c9377dbde7bef2f8adc844d5b573d45c22e61cc
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a658ef3d62485c1255e0d9ae9afaa87 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a7ea25496f13b822b07a42b123ff7dc b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a7ea25496f13b822b07a42b123ff7dc
new file mode 100644
index 0000000000000000000000000000000000000000..ce0d4d7521fb28a862be42ec25eeb48e26a2f233
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a7ea25496f13b822b07a42b123ff7dc differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8318fd061c84a50e1e14c356606676 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8318fd061c84a50e1e14c356606676
new file mode 100644
index 0000000000000000000000000000000000000000..5440332e41923beb34b6a9eb5ec6d6c1b97174c4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8318fd061c84a50e1e14c356606676 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8333d64cf6330cbb4d3dcaf685bf28 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8333d64cf6330cbb4d3dcaf685bf28
new file mode 100644
index 0000000000000000000000000000000000000000..a493ab68ab1c06d338edbd0f0a4e9a847b261ce5
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a8333d64cf6330cbb4d3dcaf685bf28 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a954ecf36a15a024cd18d69f49aa653 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a954ecf36a15a024cd18d69f49aa653
new file mode 100644
index 0000000000000000000000000000000000000000..18ccdeec0d281801d5658161c2700add097eab53
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0a954ecf36a15a024cd18d69f49aa653 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0aeac6dabbe7f04fe58a80b23d56fe81 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0aeac6dabbe7f04fe58a80b23d56fe81
new file mode 100644
index 0000000000000000000000000000000000000000..4da3fb337b72713d5cb4212aa644ded1c70f1337
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0aeac6dabbe7f04fe58a80b23d56fe81 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0afe326a01e045ff93e97573173c2994 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0afe326a01e045ff93e97573173c2994
new file mode 100644
index 0000000000000000000000000000000000000000..f7adf7fbc0549edfa2db8731cabc1e0df3cea2e5
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0a/0afe326a01e045ff93e97573173c2994 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b0523aa81a04c6d3ad13af7c2fcf4fc b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b0523aa81a04c6d3ad13af7c2fcf4fc
new file mode 100644
index 0000000000000000000000000000000000000000..6741234f7e37fd2b6b2771214e9fa93d2b66e97e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b0523aa81a04c6d3ad13af7c2fcf4fc differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b17e450e8b2e0cabe07455a71846ab6 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b17e450e8b2e0cabe07455a71846ab6
new file mode 100644
index 0000000000000000000000000000000000000000..ada828421ff1998833f703157808b24b70133045
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b17e450e8b2e0cabe07455a71846ab6 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b3bdd7067b4bc5483329c4691c9f6de b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b3bdd7067b4bc5483329c4691c9f6de
new file mode 100644
index 0000000000000000000000000000000000000000..370e3702a179abdd93c93382779cff462b479a17
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b3bdd7067b4bc5483329c4691c9f6de differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b528b0e70b829364298d8e4ae2fef8a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b528b0e70b829364298d8e4ae2fef8a
new file mode 100644
index 0000000000000000000000000000000000000000..4f2a1cdfa5d30868015887986fd418800b3f9f94
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b528b0e70b829364298d8e4ae2fef8a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b5d5edf51babb5ef9faae45a513734a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b5d5edf51babb5ef9faae45a513734a
new file mode 100644
index 0000000000000000000000000000000000000000..d34b9e39f3923f8d4c3082ce44fc7e536cdb2f72
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b5d5edf51babb5ef9faae45a513734a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b9983b7cbfe0a8da59da358baa478b3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b9983b7cbfe0a8da59da358baa478b3
new file mode 100644
index 0000000000000000000000000000000000000000..2978ef176e0023ca8e58b74b72810e7317f1800f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0b9983b7cbfe0a8da59da358baa478b3 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0baa8fe717119be1a7e126695997e15f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0baa8fe717119be1a7e126695997e15f
new file mode 100644
index 0000000000000000000000000000000000000000..421db96579734a2307f455b738be76227d241946
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0b/0baa8fe717119be1a7e126695997e15f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c3a563097a69d4e25c24403930a3ea4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c3a563097a69d4e25c24403930a3ea4
new file mode 100644
index 0000000000000000000000000000000000000000..df00265e1c10c8d8b7a3c905cd7d8d1d19c3d028
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c3a563097a69d4e25c24403930a3ea4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c6faea1d0336b981d8bad02f8324e3a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c6faea1d0336b981d8bad02f8324e3a
new file mode 100644
index 0000000000000000000000000000000000000000..a3437d0a5cd76366f482fe918625ceb3296082b2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c6faea1d0336b981d8bad02f8324e3a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8a79d3d6c71a5c2c1aff14cdd751a7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8a79d3d6c71a5c2c1aff14cdd751a7
new file mode 100644
index 0000000000000000000000000000000000000000..3c382c989af312ec8cbe45dc717891ddea71824f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8a79d3d6c71a5c2c1aff14cdd751a7 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8af4cff3966524deb834527b089319 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8af4cff3966524deb834527b089319
new file mode 100644
index 0000000000000000000000000000000000000000..31d66bdd66671ec97b14ab47854792d2fdb3e5cf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0c8af4cff3966524deb834527b089319 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0cc36a4016a5cf409a6ff40afc80b0dc b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0cc36a4016a5cf409a6ff40afc80b0dc
new file mode 100644
index 0000000000000000000000000000000000000000..a59d70376d40dadadf8d1c6c3ce6e15c5456ac8e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0c/0cc36a4016a5cf409a6ff40afc80b0dc differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d241c9d0921c3e64b67641a95f1fb43 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d241c9d0921c3e64b67641a95f1fb43
new file mode 100644
index 0000000000000000000000000000000000000000..959e1cba2a2fbbc48e36554d78ac751f9d9f2a16
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d241c9d0921c3e64b67641a95f1fb43 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d26df10f37eb06ebaa905ba3bdf0622 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d26df10f37eb06ebaa905ba3bdf0622
new file mode 100644
index 0000000000000000000000000000000000000000..d17be61847f9a41e6ad3998edf228e37ed96280a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d26df10f37eb06ebaa905ba3bdf0622 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d27a1a914b773c004fcd96c2ded20b9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d27a1a914b773c004fcd96c2ded20b9
new file mode 100644
index 0000000000000000000000000000000000000000..d6528e819f99ae1c784d99c53a6341459ad5351d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d27a1a914b773c004fcd96c2ded20b9 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d3803535c8a38bff19273ee54e9d3c8 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d3803535c8a38bff19273ee54e9d3c8
new file mode 100644
index 0000000000000000000000000000000000000000..b2d18b2ad563afd5ff51514c652f22a2f33eb3ff
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d3803535c8a38bff19273ee54e9d3c8 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d391e641a509e09e5374abae691cc40 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d391e641a509e09e5374abae691cc40
new file mode 100644
index 0000000000000000000000000000000000000000..e1838032e0817dba74a851b9d58d6d4053043a4d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0d391e641a509e09e5374abae691cc40 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dac8f9e42dc4d9162e56f25a32bb412 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dac8f9e42dc4d9162e56f25a32bb412
new file mode 100644
index 0000000000000000000000000000000000000000..16893ee8d872c35144107a30274ff7c2d335e477
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dac8f9e42dc4d9162e56f25a32bb412 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dce99b0872254bbf4b4397bc7b7c3ed b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dce99b0872254bbf4b4397bc7b7c3ed
new file mode 100644
index 0000000000000000000000000000000000000000..4428c1323f2c691bfb336aa029e07f796c8ef8d3
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/0d/0dce99b0872254bbf4b4397bc7b7c3ed differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b73eb568cb3661dce2e0329a5fda4c9d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b73eb568cb3661dce2e0329a5fda4c9d
new file mode 100644
index 0000000000000000000000000000000000000000..c220619bfd4dac8a5208c3d22badc3a38a9acc15
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b73eb568cb3661dce2e0329a5fda4c9d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b740f7706c25e3a1f93d514de0527834 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b740f7706c25e3a1f93d514de0527834
new file mode 100644
index 0000000000000000000000000000000000000000..305bda8bbb2b6acf19e451c6ad858ea34e094d57
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b740f7706c25e3a1f93d514de0527834 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b78cce3f8cc80184feb95cd56897b00a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b78cce3f8cc80184feb95cd56897b00a
new file mode 100644
index 0000000000000000000000000000000000000000..0a143f3c7517173b2f8d898313adb84c98f1806d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b78cce3f8cc80184feb95cd56897b00a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7af8dc0d56c48cf2ec8645545a3bc4e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7af8dc0d56c48cf2ec8645545a3bc4e
new file mode 100644
index 0000000000000000000000000000000000000000..8dda38749a04af92ebeae4627f2f20d38aefb58b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7af8dc0d56c48cf2ec8645545a3bc4e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7bc6bc97cbbb4a6ee90d78cb7e9aecb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7bc6bc97cbbb4a6ee90d78cb7e9aecb
new file mode 100644
index 0000000000000000000000000000000000000000..6f0383d8dcca14f8f1a63211fce0ee0164835c72
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7bc6bc97cbbb4a6ee90d78cb7e9aecb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7cab6933e5bcfbdf56de0342118971f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7cab6933e5bcfbdf56de0342118971f
new file mode 100644
index 0000000000000000000000000000000000000000..e4e18cb58b3074d0e43f99af0994529ea2093796
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7cab6933e5bcfbdf56de0342118971f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7f2fe597e532f1ba20e62807552443e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7f2fe597e532f1ba20e62807552443e
new file mode 100644
index 0000000000000000000000000000000000000000..c545c68923ce78a7a5a4d5cd108d035bae616d79
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7f2fe597e532f1ba20e62807552443e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7fb189bb5135c9032e924f92b4f49f3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7fb189bb5135c9032e924f92b4f49f3
new file mode 100644
index 0000000000000000000000000000000000000000..1f26b56918c1533ff64346307a8307594a634c74
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b7/b7fb189bb5135c9032e924f92b4f49f3 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b81e3d2674ccafddac1188c364a4aec2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b81e3d2674ccafddac1188c364a4aec2
new file mode 100644
index 0000000000000000000000000000000000000000..b82b1faa44461ebebf3efaaa4667f82af0aeaa41
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b81e3d2674ccafddac1188c364a4aec2 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b828a7643fed5aa0d8b6b9fe56fd6a6f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b828a7643fed5aa0d8b6b9fe56fd6a6f
new file mode 100644
index 0000000000000000000000000000000000000000..daa1eb2ec1a22ce72de17a3f89e1e813ed77deb7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b828a7643fed5aa0d8b6b9fe56fd6a6f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b85fd62a0e37c4d66f13495fd2ad360e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b85fd62a0e37c4d66f13495fd2ad360e
new file mode 100644
index 0000000000000000000000000000000000000000..bf22748ea89f211c7455abea3c431d0a33872596
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b85fd62a0e37c4d66f13495fd2ad360e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b86d158cbb9f8e40e7d1e76a430cc920 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b86d158cbb9f8e40e7d1e76a430cc920
new file mode 100644
index 0000000000000000000000000000000000000000..1c734d759210ec3daf46498d03ae32199a18bb19
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b86d158cbb9f8e40e7d1e76a430cc920 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8991a16ac685e583c4ad27006ade9d1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8991a16ac685e583c4ad27006ade9d1
new file mode 100644
index 0000000000000000000000000000000000000000..f8d012cd363c4b7be7889534a792a5d06c8e4f23
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8991a16ac685e583c4ad27006ade9d1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8b37f3b238b71cfd543fdd633fdb497 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8b37f3b238b71cfd543fdd633fdb497
new file mode 100644
index 0000000000000000000000000000000000000000..f9e874e00bd2e0f7eba87f2e5a710670f079494e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b8/b8b37f3b238b71cfd543fdd633fdb497 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b90ceebd2268965af46af406f5bfe412 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b90ceebd2268965af46af406f5bfe412
new file mode 100644
index 0000000000000000000000000000000000000000..d2dc22c0cd6979d06898c1a8a8055c6a32316772
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b90ceebd2268965af46af406f5bfe412 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b919ea0fd70ed8a56abfe6bca80b6e08 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b919ea0fd70ed8a56abfe6bca80b6e08
new file mode 100644
index 0000000000000000000000000000000000000000..a706ab79c12a9053f313bbd3259977e779baad54
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b919ea0fd70ed8a56abfe6bca80b6e08 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93554fa0e70f67262b054869c43fcaf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93554fa0e70f67262b054869c43fcaf
new file mode 100644
index 0000000000000000000000000000000000000000..e7fb7f40f685981009db87c6a4bb055bc2c34ea4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93554fa0e70f67262b054869c43fcaf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93a658158deee194c456c5be289aac9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93a658158deee194c456c5be289aac9
new file mode 100644
index 0000000000000000000000000000000000000000..c0bf05b19712ffaecefc7ed399f50175d6c71b7d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93a658158deee194c456c5be289aac9 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93ea67fc21d9b1591ba42727474a76e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93ea67fc21d9b1591ba42727474a76e
new file mode 100644
index 0000000000000000000000000000000000000000..11e9c9b63937271f2eb579f0157c56a9d6cd86a0
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b93ea67fc21d9b1591ba42727474a76e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9572c6354c60393b46997b99659b029 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9572c6354c60393b46997b99659b029
new file mode 100644
index 0000000000000000000000000000000000000000..a46e31c3ba8d020e6ca6139f31b0f90d3e34521f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9572c6354c60393b46997b99659b029 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b95f0cac2b7eb53a50f401ab2caec757 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b95f0cac2b7eb53a50f401ab2caec757
new file mode 100644
index 0000000000000000000000000000000000000000..00418d34c35287277310bc3c79cb99a80e494c67
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b95f0cac2b7eb53a50f401ab2caec757 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b97f5c3566c7b4727ff983ddfd465623 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b97f5c3566c7b4727ff983ddfd465623
new file mode 100644
index 0000000000000000000000000000000000000000..cce6ab40faa54fbc9ab524b997397cbbc7e8578f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b97f5c3566c7b4727ff983ddfd465623 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b98aad488551a0f8f3d2426e28605d04 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b98aad488551a0f8f3d2426e28605d04
new file mode 100644
index 0000000000000000000000000000000000000000..7f9e26cc8e5129f939cf40b2d861e21676b8500c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b98aad488551a0f8f3d2426e28605d04 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b997d32c9fa80a96547249907b6b4651 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b997d32c9fa80a96547249907b6b4651
new file mode 100644
index 0000000000000000000000000000000000000000..c73cdb43e7fa3ef74245e08cd0088966745d64d2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b997d32c9fa80a96547249907b6b4651 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9c7fc0a324d9c23c3f8ada4176721cb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9c7fc0a324d9c23c3f8ada4176721cb
new file mode 100644
index 0000000000000000000000000000000000000000..ebf7e1474e556b3f3c50fbc0c95b27ef64714a07
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/b9/b9c7fc0a324d9c23c3f8ada4176721cb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba47dbbc4c9eb85461037e75cc8f7ad0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba47dbbc4c9eb85461037e75cc8f7ad0
new file mode 100644
index 0000000000000000000000000000000000000000..2592d20ba246c970fc6c3ef2cbf45b622b3c7061
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba47dbbc4c9eb85461037e75cc8f7ad0 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4b44da214023229f82100a69aff8f6 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4b44da214023229f82100a69aff8f6
new file mode 100644
index 0000000000000000000000000000000000000000..a48e3a50a63355a8e7969eb5a5f8c0855273760f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4b44da214023229f82100a69aff8f6 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4fcca6129976529bbe09e9cc98fc73 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4fcca6129976529bbe09e9cc98fc73
new file mode 100644
index 0000000000000000000000000000000000000000..0ac6a173e497ed02d72604a31974c7146027697d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba4fcca6129976529bbe09e9cc98fc73 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba54f7e0ba84e69ab0a0f318e0a10eb0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba54f7e0ba84e69ab0a0f318e0a10eb0
new file mode 100644
index 0000000000000000000000000000000000000000..e2c47ad9bfb001b9cfcd0d4e3c6fc18609fbd96b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba54f7e0ba84e69ab0a0f318e0a10eb0 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba59dd410c1452ca40fc144cd5d13c21 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba59dd410c1452ca40fc144cd5d13c21
new file mode 100644
index 0000000000000000000000000000000000000000..6ccc25396259a6aa346cb4553aa4f3640bb9faac
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba59dd410c1452ca40fc144cd5d13c21 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba7d42894812d45ca230bfc1f3174226 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba7d42894812d45ca230bfc1f3174226
new file mode 100644
index 0000000000000000000000000000000000000000..93d6fbca5cac3e00f613d6de056f0b4166aff3a7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/ba7d42894812d45ca230bfc1f3174226 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/baa3ec2c2336e52107def691e2783308 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/baa3ec2c2336e52107def691e2783308
new file mode 100644
index 0000000000000000000000000000000000000000..9da7f959735c7015a58f2a5c212cbaec27eb57a9
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/baa3ec2c2336e52107def691e2783308 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babaa87dbb25cdf71a6ace792b767bf8 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babaa87dbb25cdf71a6ace792b767bf8
new file mode 100644
index 0000000000000000000000000000000000000000..7e5ce32f8285e28572a0dc137ffbf5f9f1700a4e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babaa87dbb25cdf71a6ace792b767bf8 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babab2cc5c62b4e8229a9adf1d5f9acf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babab2cc5c62b4e8229a9adf1d5f9acf
new file mode 100644
index 0000000000000000000000000000000000000000..154bd1b4a4e7f798d551807c52ec8a3eccb5cdf3
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/babab2cc5c62b4e8229a9adf1d5f9acf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/bafe5c4f3f1a79062bd178574074b362 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/bafe5c4f3f1a79062bd178574074b362
new file mode 100644
index 0000000000000000000000000000000000000000..91adbfe1f1865568e2f73c70fea8b944f36b124c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ba/bafe5c4f3f1a79062bd178574074b362 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2623374b9596b44f0f49921c00dd39 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2623374b9596b44f0f49921c00dd39
new file mode 100644
index 0000000000000000000000000000000000000000..c0d2066f3a221ebd2ea4b957d200dbd80294d24a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2623374b9596b44f0f49921c00dd39 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2c112e367ecd96ff553436f476eab7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2c112e367ecd96ff553436f476eab7
new file mode 100644
index 0000000000000000000000000000000000000000..484bba317ca4f5fb9f8cdf90450e8a5af2ffb372
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb2c112e367ecd96ff553436f476eab7 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb3b7ba6aa063b9fed7950d79360b630 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb3b7ba6aa063b9fed7950d79360b630
new file mode 100644
index 0000000000000000000000000000000000000000..82b60897b722d51ff3727123bdc5330297e885be
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb3b7ba6aa063b9fed7950d79360b630 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb40c3bcdd0769ac1e87884112765312 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb40c3bcdd0769ac1e87884112765312
new file mode 100644
index 0000000000000000000000000000000000000000..0df1e030a3c0fe92481721a2a5db5f7d3b427665
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb40c3bcdd0769ac1e87884112765312 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb44baea406f781c89ea3913ce340e7d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb44baea406f781c89ea3913ce340e7d
new file mode 100644
index 0000000000000000000000000000000000000000..ce82fac540b47b2e616defebdfcf8214b9879feb
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb44baea406f781c89ea3913ce340e7d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb9050d277be1c2c62b3947ffa10d820 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb9050d277be1c2c62b3947ffa10d820
new file mode 100644
index 0000000000000000000000000000000000000000..99fe7a3bd51067d62ceb5caa1a1c55378c35637e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb9050d277be1c2c62b3947ffa10d820 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb926882596c6e1c7df93ab94873ca4c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb926882596c6e1c7df93ab94873ca4c
new file mode 100644
index 0000000000000000000000000000000000000000..a0f1ff13c909683654433d7ecc37f2b591257f12
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bb926882596c6e1c7df93ab94873ca4c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bba32db5e449e6f31c36408295669201 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bba32db5e449e6f31c36408295669201
new file mode 100644
index 0000000000000000000000000000000000000000..8f0f3b749dff6c9c670ceb5c7956cc3dc1763ebf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bba32db5e449e6f31c36408295669201 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbc133d48c4af49b65d0747a5f82ad8a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbc133d48c4af49b65d0747a5f82ad8a
new file mode 100644
index 0000000000000000000000000000000000000000..5e75bc6ad8e656a2ca2d0f9ebb0ce25d4a06d9bf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbc133d48c4af49b65d0747a5f82ad8a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf2ea85c1fe97d44dcf7f144dc2a4ab b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf2ea85c1fe97d44dcf7f144dc2a4ab
new file mode 100644
index 0000000000000000000000000000000000000000..09a832b943678ae5a086ba298faee08d499cb8cc
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf2ea85c1fe97d44dcf7f144dc2a4ab differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf4a5cffc0edaeab82ea349752aa3a6 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf4a5cffc0edaeab82ea349752aa3a6
new file mode 100644
index 0000000000000000000000000000000000000000..add1464388ac7e3252e828339e4bae0f1c1ba0cf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bb/bbf4a5cffc0edaeab82ea349752aa3a6 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc05193f38c94b7362d10000a0d82247 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc05193f38c94b7362d10000a0d82247
new file mode 100644
index 0000000000000000000000000000000000000000..5ffbd017e88a0991ed34a121d31a1b09d7735e01
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc05193f38c94b7362d10000a0d82247 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc1cccb4140b8b09bc3cccf0c56b46c3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc1cccb4140b8b09bc3cccf0c56b46c3
new file mode 100644
index 0000000000000000000000000000000000000000..5b3bee25fadc8526eac9e69c550077703c595c75
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc1cccb4140b8b09bc3cccf0c56b46c3 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc8a97346ebb48bfdc6a2f49067c8a39 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc8a97346ebb48bfdc6a2f49067c8a39
new file mode 100644
index 0000000000000000000000000000000000000000..a20ad1f4fe1e5a265cb3faeb13962abf14a4cc92
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bc8a97346ebb48bfdc6a2f49067c8a39 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bca629741c4d178b850a12356292e5f9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bca629741c4d178b850a12356292e5f9
new file mode 100644
index 0000000000000000000000000000000000000000..7f456b0277e8759167e4cc34dccc7c8626dd0f20
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bca629741c4d178b850a12356292e5f9 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcb6ba823d1c128f9e68fc4fa1c8ca82 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcb6ba823d1c128f9e68fc4fa1c8ca82
new file mode 100644
index 0000000000000000000000000000000000000000..30d3bb91302b95c12dabd481b9bf3c2f11c62f66
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcb6ba823d1c128f9e68fc4fa1c8ca82 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bccd157bbb27bf8511cda839cd887a77 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bccd157bbb27bf8511cda839cd887a77
new file mode 100644
index 0000000000000000000000000000000000000000..94716e5465a7f6c46c0a9f252b2416176ad94b65
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bccd157bbb27bf8511cda839cd887a77 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcd1c7bff048c35248b39cd86f823d76 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcd1c7bff048c35248b39cd86f823d76
new file mode 100644
index 0000000000000000000000000000000000000000..b0242884008b160206c657a6dd0260ff32dbaf82
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcd1c7bff048c35248b39cd86f823d76 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcdb5e52670d25656cb16ef39680cbf2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcdb5e52670d25656cb16ef39680cbf2
new file mode 100644
index 0000000000000000000000000000000000000000..f8736e15c1db9286f008edcb02256cf5cacf009b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcdb5e52670d25656cb16ef39680cbf2 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcde378625c27c673968d7e75fe6d999 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcde378625c27c673968d7e75fe6d999
new file mode 100644
index 0000000000000000000000000000000000000000..f5b82f941b5380c59c2b0934c6e545560337c92a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bc/bcde378625c27c673968d7e75fe6d999 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd0764a534a74555a283c7841acb6ce4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd0764a534a74555a283c7841acb6ce4
new file mode 100644
index 0000000000000000000000000000000000000000..24596241633e70b7fc23eef65ccc2f21a8fca1d4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd0764a534a74555a283c7841acb6ce4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd117b5e7973539b8ce1c5905c55242c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd117b5e7973539b8ce1c5905c55242c
new file mode 100644
index 0000000000000000000000000000000000000000..5d9dbc3fb2bf2aa28ee2f130f69cc83e981498ae
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd117b5e7973539b8ce1c5905c55242c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd17e7a8c9f839bc61655210dcb143f7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd17e7a8c9f839bc61655210dcb143f7
new file mode 100644
index 0000000000000000000000000000000000000000..10faabbe04a754be53c99e3b7b43610893d9c4f3
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd17e7a8c9f839bc61655210dcb143f7 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd1a3eb31cae2c9a42126dc11b18d520 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd1a3eb31cae2c9a42126dc11b18d520
new file mode 100644
index 0000000000000000000000000000000000000000..48456f9649d2c1e94871fdaa72fc6bfaa47273da
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd1a3eb31cae2c9a42126dc11b18d520 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd271315b9f56bf2258b3e6685d94398 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd271315b9f56bf2258b3e6685d94398
new file mode 100644
index 0000000000000000000000000000000000000000..8f9cb7a2fdf78f83060cb7a97ca0a41197a9bd15
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd271315b9f56bf2258b3e6685d94398 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd36059197ea9ce8efa96e357887462c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd36059197ea9ce8efa96e357887462c
new file mode 100644
index 0000000000000000000000000000000000000000..31160e3787662246d737f2ba33d82ccc439b8bde
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd36059197ea9ce8efa96e357887462c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd3a6766c9310c6e325ac93373477c7f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd3a6766c9310c6e325ac93373477c7f
new file mode 100644
index 0000000000000000000000000000000000000000..e510d8a165793f3a6b19dd1328023725f5174e8e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd3a6766c9310c6e325ac93373477c7f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd68e130e7c5d85941ca8f2e4c73fc9c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd68e130e7c5d85941ca8f2e4c73fc9c
new file mode 100644
index 0000000000000000000000000000000000000000..c4e92ae20ecde204290a2e40dc2f5d2bc697b0be
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd68e130e7c5d85941ca8f2e4c73fc9c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd79b14756f32e22c547968a0ee2e62f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd79b14756f32e22c547968a0ee2e62f
new file mode 100644
index 0000000000000000000000000000000000000000..8bee02587f03c7718109c1ed3bab1094134beef6
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd79b14756f32e22c547968a0ee2e62f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd8ec10cef9f4562331a3869c38c5b92 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd8ec10cef9f4562331a3869c38c5b92
new file mode 100644
index 0000000000000000000000000000000000000000..a117d23b82e96a82745677484b83820033a18d72
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bd8ec10cef9f4562331a3869c38c5b92 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bda03a586d0f9cbe4ddd69a4c560bb9a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bda03a586d0f9cbe4ddd69a4c560bb9a
new file mode 100644
index 0000000000000000000000000000000000000000..83abac585a8fe7f5006466822688dc6df401231a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bda03a586d0f9cbe4ddd69a4c560bb9a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bdb50b525c256822a93db8347b6b3fe5 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bdb50b525c256822a93db8347b6b3fe5
new file mode 100644
index 0000000000000000000000000000000000000000..9d156d084d601becc91bc87e039cfc24f6e922e8
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bd/bdb50b525c256822a93db8347b6b3fe5 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be030d5e8c2d936d4a1d8a8471a4eb3f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be030d5e8c2d936d4a1d8a8471a4eb3f
new file mode 100644
index 0000000000000000000000000000000000000000..e629efe90e6e8897e03ebba33400da0ca78e0ebd
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be030d5e8c2d936d4a1d8a8471a4eb3f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1c74110d68ea7d55b1de980bff8205 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1c74110d68ea7d55b1de980bff8205
new file mode 100644
index 0000000000000000000000000000000000000000..9b74b15346db59e308460873c21ad723f6e82542
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1c74110d68ea7d55b1de980bff8205 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1ea7ac5e8f73f478402a7b3e78f072 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1ea7ac5e8f73f478402a7b3e78f072
new file mode 100644
index 0000000000000000000000000000000000000000..492fb8dcc958fa19e149ff4f3ed5d23a70efe96b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be1ea7ac5e8f73f478402a7b3e78f072 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be227c251b11bbab6c49b71a7a9a3db8 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be227c251b11bbab6c49b71a7a9a3db8
new file mode 100644
index 0000000000000000000000000000000000000000..7ccb14f57869d64ccc0d2e6932dcb0bb65e48496
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be227c251b11bbab6c49b71a7a9a3db8 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be7ffc4a344d6069a7c69f8089694fce b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be7ffc4a344d6069a7c69f8089694fce
new file mode 100644
index 0000000000000000000000000000000000000000..0fb5f8de681ad25a885ba2473464b4242f16d4ca
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be7ffc4a344d6069a7c69f8089694fce differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be917591a6ba3c9bd083d5c04b1f587c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be917591a6ba3c9bd083d5c04b1f587c
new file mode 100644
index 0000000000000000000000000000000000000000..ccb6f5cb5b992337e166c1a57c62bb017445e2a0
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/be917591a6ba3c9bd083d5c04b1f587c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bec2f4949afc38a8b3c179f0466ec823 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bec2f4949afc38a8b3c179f0466ec823
new file mode 100644
index 0000000000000000000000000000000000000000..280b3a86cb703803d141e737f97c5c33514ff27e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bec2f4949afc38a8b3c179f0466ec823 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bed375e88f07c314bb7b451af957fd82 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bed375e88f07c314bb7b451af957fd82
new file mode 100644
index 0000000000000000000000000000000000000000..59a6bde56a89a6fdb953e9ef0d5bbad6217d9a75
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bed375e88f07c314bb7b451af957fd82 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bef9dbeb3faa715e16af42fb2710424b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bef9dbeb3faa715e16af42fb2710424b
new file mode 100644
index 0000000000000000000000000000000000000000..5aba3fd3ae9d23ae32192750a6ebf5ac5c5e3332
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/be/bef9dbeb3faa715e16af42fb2710424b differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf09d9e56e6aea78f5d88e184f8c313a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf09d9e56e6aea78f5d88e184f8c313a
new file mode 100644
index 0000000000000000000000000000000000000000..e1ba24e06c3dd7fd0f9b8a04a31fc7a00f128bab
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf09d9e56e6aea78f5d88e184f8c313a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf258b39d0e4445b0788363448b3c43a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf258b39d0e4445b0788363448b3c43a
new file mode 100644
index 0000000000000000000000000000000000000000..903b855f99c5d456d59b74c3a5954b7e617ceeb4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf258b39d0e4445b0788363448b3c43a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf2a1eb7ea0c0b9c12258744578c368a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf2a1eb7ea0c0b9c12258744578c368a
new file mode 100644
index 0000000000000000000000000000000000000000..fc8aef5135b0be6620335c36da2bd423ee330886
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf2a1eb7ea0c0b9c12258744578c368a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf55ffe1a6beb5b1490f310980e2d0de b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf55ffe1a6beb5b1490f310980e2d0de
new file mode 100644
index 0000000000000000000000000000000000000000..7a7c9bad213d0a951c1a04e01f99b65e9c27d953
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf55ffe1a6beb5b1490f310980e2d0de differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf879d6e9cf8d38b7af95e7aa4bd3477 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf879d6e9cf8d38b7af95e7aa4bd3477
new file mode 100644
index 0000000000000000000000000000000000000000..64ec271153efb5bb9ac80f5b8565e130699edd8c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf879d6e9cf8d38b7af95e7aa4bd3477 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf9bfdfc9c524379fc8a8341defe976e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf9bfdfc9c524379fc8a8341defe976e
new file mode 100644
index 0000000000000000000000000000000000000000..6770158c67dd958a953d415ff8e3cd5063a9a8e7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bf9bfdfc9c524379fc8a8341defe976e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfb14d3410645ebe21b4b2a9372c0dcb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfb14d3410645ebe21b4b2a9372c0dcb
new file mode 100644
index 0000000000000000000000000000000000000000..e3f1378285fb525851768b4bc85b30c7fcdc4829
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfb14d3410645ebe21b4b2a9372c0dcb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfd47ad06acd1952232a255012f9fe0e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfd47ad06acd1952232a255012f9fe0e
new file mode 100644
index 0000000000000000000000000000000000000000..fd9d7c08a76caf13c159b0c21e270da5e5ba5bad
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/bf/bfd47ad06acd1952232a255012f9fe0e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0056995c5c570c9528dee46efa019e9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0056995c5c570c9528dee46efa019e9
new file mode 100644
index 0000000000000000000000000000000000000000..92693ab5c38114bd593243fdba5733ff25e5f69b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0056995c5c570c9528dee46efa019e9 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0067d2a40bac7517ca3b13fe1a5b536 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0067d2a40bac7517ca3b13fe1a5b536
new file mode 100644
index 0000000000000000000000000000000000000000..bfe43abe6ae3dce0376c54d4c8c13486d1f80299
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0067d2a40bac7517ca3b13fe1a5b536 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c04a80252115b20e86070b886d487f21 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c04a80252115b20e86070b886d487f21
new file mode 100644
index 0000000000000000000000000000000000000000..42866039ee21798be81ba5851a31fea2b5fdfd30
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c04a80252115b20e86070b886d487f21 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c058e67902f54942a1d4ba9e98a29be1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c058e67902f54942a1d4ba9e98a29be1
new file mode 100644
index 0000000000000000000000000000000000000000..dea7c41c8f63ab37a375de91f4dec704468ce9b2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c058e67902f54942a1d4ba9e98a29be1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c077ab2c52e3b4c923812b107f7ee606 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c077ab2c52e3b4c923812b107f7ee606
new file mode 100644
index 0000000000000000000000000000000000000000..6ead1005f2fbfcacbeb3ee8a45a9284bc3db9e8e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c077ab2c52e3b4c923812b107f7ee606 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0868fa698243a99d1b1e0865ab61c0d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0868fa698243a99d1b1e0865ab61c0d
new file mode 100644
index 0000000000000000000000000000000000000000..74ecce0624ef59495536c681a38a1a03675a25ee
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0868fa698243a99d1b1e0865ab61c0d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c092377a7082f8c921a2f1da8452f819 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c092377a7082f8c921a2f1da8452f819
new file mode 100644
index 0000000000000000000000000000000000000000..b4e3af9e7347fc7be9f97ec2a98aa44478562450
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c092377a7082f8c921a2f1da8452f819 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0b876721297284e794ccb0469eb5d32 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0b876721297284e794ccb0469eb5d32
new file mode 100644
index 0000000000000000000000000000000000000000..7c532fe89fe615170118413c02093d2c58ebecb3
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0b876721297284e794ccb0469eb5d32 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0c213f10b423bd5cd9fd85ab2f0edfc b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0c213f10b423bd5cd9fd85ab2f0edfc
new file mode 100644
index 0000000000000000000000000000000000000000..11cc59ce4097a035b0648425b1e67e5baad87e64
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0c213f10b423bd5cd9fd85ab2f0edfc differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0d3798bd24d85a6e33cd45a7f76c79a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0d3798bd24d85a6e33cd45a7f76c79a
new file mode 100644
index 0000000000000000000000000000000000000000..ab26411840ec750d590f62bdce47685fa651281b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0d3798bd24d85a6e33cd45a7f76c79a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0de5240c25b4637a8d832b4539a5ebf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0de5240c25b4637a8d832b4539a5ebf
new file mode 100644
index 0000000000000000000000000000000000000000..01449e4846ce108c6dc1955584aaaecb1c334c51
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0de5240c25b4637a8d832b4539a5ebf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0e845727a65da5d49c33fd8d142a660 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0e845727a65da5d49c33fd8d142a660
new file mode 100644
index 0000000000000000000000000000000000000000..8049b652db97ca9c91b1c4290aef89d42ad76b62
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c0/c0e845727a65da5d49c33fd8d142a660 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c10ac88cf38b30b8364148c2fa331852 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c10ac88cf38b30b8364148c2fa331852
new file mode 100644
index 0000000000000000000000000000000000000000..9254e694844d7f95f76e1c2a823de839ca12fb3c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c10ac88cf38b30b8364148c2fa331852 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1277c1edfb11682e647276254d13ecb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1277c1edfb11682e647276254d13ecb
new file mode 100644
index 0000000000000000000000000000000000000000..6e6ad4300bfba0622ba7e07fc1c2c5b644bcdccc
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1277c1edfb11682e647276254d13ecb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c13c3a9a903291dd95974953425fa479 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c13c3a9a903291dd95974953425fa479
new file mode 100644
index 0000000000000000000000000000000000000000..1cd48d9cb50a13861d37e6a0b8617cfc56509ebc
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c13c3a9a903291dd95974953425fa479 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c158e557185ed661b39e1debdca08332 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c158e557185ed661b39e1debdca08332
new file mode 100644
index 0000000000000000000000000000000000000000..d8dfe47e4b7deb8a73db2359e8a83e404c35110a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c158e557185ed661b39e1debdca08332 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15be7f18a0e471db1213dc396b3175b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15be7f18a0e471db1213dc396b3175b
new file mode 100644
index 0000000000000000000000000000000000000000..1896dd120c4cae1be3193693a40de4baa87b436e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15be7f18a0e471db1213dc396b3175b differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15d1891deafb7056113c30d3eaf85b4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15d1891deafb7056113c30d3eaf85b4
new file mode 100644
index 0000000000000000000000000000000000000000..4f2d626b610544ef8859c0402fed5c1e724f3f71
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c15d1891deafb7056113c30d3eaf85b4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c16fa3b738bb19759760a7be0d7c84f7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c16fa3b738bb19759760a7be0d7c84f7
new file mode 100644
index 0000000000000000000000000000000000000000..a7a7b22cee0d3ffdbb9f6038dfbeb36aa3dd860c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c16fa3b738bb19759760a7be0d7c84f7 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c17ba366c58d46c3b238b2e831473f30 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c17ba366c58d46c3b238b2e831473f30
new file mode 100644
index 0000000000000000000000000000000000000000..b2d298a41aa846e00056750a3b9d252b9d1e941d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c17ba366c58d46c3b238b2e831473f30 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1884e0e81593ea5ba0c0aa4f00e879b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1884e0e81593ea5ba0c0aa4f00e879b
new file mode 100644
index 0000000000000000000000000000000000000000..eb1456b19194fc52554e54d359c45541fb6781a6
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1884e0e81593ea5ba0c0aa4f00e879b differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c19c155c2801a8269d46f65669e82440 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c19c155c2801a8269d46f65669e82440
new file mode 100644
index 0000000000000000000000000000000000000000..3f7bb3653d5756243ea9daf763427bb58694da86
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c19c155c2801a8269d46f65669e82440 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1a7e0aba18a51e5bab6671b5a486476 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1a7e0aba18a51e5bab6671b5a486476
new file mode 100644
index 0000000000000000000000000000000000000000..ccda2871064d785ff35e67a508994f24be33413b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1a7e0aba18a51e5bab6671b5a486476 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c55aa73fd54b86c5300874a8a1bd87 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c55aa73fd54b86c5300874a8a1bd87
new file mode 100644
index 0000000000000000000000000000000000000000..c3216b0ecbb577d3f1b98788443702a74edc0172
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c55aa73fd54b86c5300874a8a1bd87 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c75a758bbfc1517b8f62fc6b8e1ec7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c75a758bbfc1517b8f62fc6b8e1ec7
new file mode 100644
index 0000000000000000000000000000000000000000..a07af661486a2d14b10858ebdfbc0d9f7365a4b8
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1c75a758bbfc1517b8f62fc6b8e1ec7 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1fc043dfcb727c3a9407be18538699c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1fc043dfcb727c3a9407be18538699c
new file mode 100644
index 0000000000000000000000000000000000000000..2f88f3d8303c8ebb44e874338224c49a75b0d4ee
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c1/c1fc043dfcb727c3a9407be18538699c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c202e12e0f71ecf56eadd7a20a1714cb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c202e12e0f71ecf56eadd7a20a1714cb
new file mode 100644
index 0000000000000000000000000000000000000000..c89cf73b3183a7f017ba6bc9ed2d4cf7c5aaf851
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c202e12e0f71ecf56eadd7a20a1714cb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2202e43abeb8a960d273a15ac7c528b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2202e43abeb8a960d273a15ac7c528b
new file mode 100644
index 0000000000000000000000000000000000000000..cebef81bd094183838fef57738889e0e6b20c7f9
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2202e43abeb8a960d273a15ac7c528b differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c288527185e250d61640cfdf3d6908e2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c288527185e250d61640cfdf3d6908e2
new file mode 100644
index 0000000000000000000000000000000000000000..d959fb60c944c395c64271043efa7ff6f5a4b4a2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c288527185e250d61640cfdf3d6908e2 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2aac2564e22533cb413478e92bde4f0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2aac2564e22533cb413478e92bde4f0
new file mode 100644
index 0000000000000000000000000000000000000000..7b8627b35fc51aeb652ddad1dec070597d78f3f8
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2aac2564e22533cb413478e92bde4f0 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2ec05136da3beb44ec18c76d0d1dd8c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2ec05136da3beb44ec18c76d0d1dd8c
new file mode 100644
index 0000000000000000000000000000000000000000..b15e339ed2ae1a3260e46c1ea4a010c599e53542
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c2/c2ec05136da3beb44ec18c76d0d1dd8c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c31cec3cc84ff1e94c04c818d0737e5a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c31cec3cc84ff1e94c04c818d0737e5a
new file mode 100644
index 0000000000000000000000000000000000000000..de7bb1ff66a7135132c35c5d8599dacf2d44eb4f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c31cec3cc84ff1e94c04c818d0737e5a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c33d350d6645dc6db76a5d3618847ad1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c33d350d6645dc6db76a5d3618847ad1
new file mode 100644
index 0000000000000000000000000000000000000000..2e40fbcaf214a02d5ec772647fbd36dae9bd441e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c33d350d6645dc6db76a5d3618847ad1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c357093e9d617acd53cd204ea25b0400 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c357093e9d617acd53cd204ea25b0400
new file mode 100644
index 0000000000000000000000000000000000000000..c2b8e9b185c4b2a9693fc71cad41eca858b6f26e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c357093e9d617acd53cd204ea25b0400 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c36ad0b29f9c812010bc5023dd4396b1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c36ad0b29f9c812010bc5023dd4396b1
new file mode 100644
index 0000000000000000000000000000000000000000..7ebd90ed36fc25ed9422fcede75cb91f25694b62
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c36ad0b29f9c812010bc5023dd4396b1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c373e332d2f53787b9fee2af77deab8a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c373e332d2f53787b9fee2af77deab8a
new file mode 100644
index 0000000000000000000000000000000000000000..cf6e06c301edca0184924ebda84f19203569196e
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c373e332d2f53787b9fee2af77deab8a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c376ad65e2476ddbf564bb5eb537bb53 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c376ad65e2476ddbf564bb5eb537bb53
new file mode 100644
index 0000000000000000000000000000000000000000..e053cd31055811231d47e4039946cab4c22140fb
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c376ad65e2476ddbf564bb5eb537bb53 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c38bb8b3bab5ca14f17c92a383504ffd b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c38bb8b3bab5ca14f17c92a383504ffd
new file mode 100644
index 0000000000000000000000000000000000000000..bfaed18ebc30abee554896f6daf9f4f204007439
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c38bb8b3bab5ca14f17c92a383504ffd differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c390f89de48140c8d37063f112426355 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c390f89de48140c8d37063f112426355
new file mode 100644
index 0000000000000000000000000000000000000000..2f292f93aec0c6638a2c4caedcde654c5f09a51a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c390f89de48140c8d37063f112426355 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3b8573f7f6207eabcb2338043e457bf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3b8573f7f6207eabcb2338043e457bf
new file mode 100644
index 0000000000000000000000000000000000000000..b2cc380e558ccd1940f7de7c44b443d63c004b29
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3b8573f7f6207eabcb2338043e457bf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3c0aad898265f4f8e5316892aedd20c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3c0aad898265f4f8e5316892aedd20c
new file mode 100644
index 0000000000000000000000000000000000000000..bc368e792e81c7d469ed9239548e5435e1bdab30
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3c0aad898265f4f8e5316892aedd20c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3cea022ae06eb91d16cda3bd800330e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3cea022ae06eb91d16cda3bd800330e
new file mode 100644
index 0000000000000000000000000000000000000000..188d9ae6758ab31868245c6c5dbad0d807c6e456
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c3/c3cea022ae06eb91d16cda3bd800330e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c412c366c5d43e530d8228670be38437 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c412c366c5d43e530d8228670be38437
new file mode 100644
index 0000000000000000000000000000000000000000..1696d334c7f7b5e7fc78349de345558c24997976
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c412c366c5d43e530d8228670be38437 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c43b0c1023683e1bb5968f09a6b6df95 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c43b0c1023683e1bb5968f09a6b6df95
new file mode 100644
index 0000000000000000000000000000000000000000..2b9e38d0e0b565bc977e87294de50cab043648f4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c43b0c1023683e1bb5968f09a6b6df95 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c460bcdf69a634ef3e138be0ca4cb0e0 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c460bcdf69a634ef3e138be0ca4cb0e0
new file mode 100644
index 0000000000000000000000000000000000000000..7238039092fa9beeb36d904182ecd7db054cf8b0
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c460bcdf69a634ef3e138be0ca4cb0e0 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c480b5d3f52d5dac0196a6dfe50936dd b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c480b5d3f52d5dac0196a6dfe50936dd
new file mode 100644
index 0000000000000000000000000000000000000000..7cc454de31834fd07d861139e6bc4d1c8b0d0f81
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c480b5d3f52d5dac0196a6dfe50936dd differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c48b8ab543db9c218478933d5d52cda4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c48b8ab543db9c218478933d5d52cda4
new file mode 100644
index 0000000000000000000000000000000000000000..50aa50fd664132504a7113a3f10ec2dadc195a0d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c48b8ab543db9c218478933d5d52cda4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4964977a72d8d61ac14eb81345b6a66 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4964977a72d8d61ac14eb81345b6a66
new file mode 100644
index 0000000000000000000000000000000000000000..ad01b973865629ee8ee88e32d53bd68dd28bbe50
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4964977a72d8d61ac14eb81345b6a66 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4c6c106b21b4341ef5459b372f20253 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4c6c106b21b4341ef5459b372f20253
new file mode 100644
index 0000000000000000000000000000000000000000..559249db97350cde3963b968bbad8dc38c170fb1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4c6c106b21b4341ef5459b372f20253 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4ece73f4ef97fcd01fd606e6d4cf3b4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4ece73f4ef97fcd01fd606e6d4cf3b4
new file mode 100644
index 0000000000000000000000000000000000000000..cd83dd1452037a46097e3e17369b65b227c4badf
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4ece73f4ef97fcd01fd606e6d4cf3b4 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f5b2ca07178f2cc7d0fb48bd87f51f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f5b2ca07178f2cc7d0fb48bd87f51f
new file mode 100644
index 0000000000000000000000000000000000000000..5a04399440a2ecdbb32e6f05eb56a2de2f303ec7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f5b2ca07178f2cc7d0fb48bd87f51f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f81af2ef329328849f5990beb51012 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f81af2ef329328849f5990beb51012
new file mode 100644
index 0000000000000000000000000000000000000000..6731abffd4dd3d562295dfd8d6f7289b1e69346a
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4f81af2ef329328849f5990beb51012 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fba652ebbcee419b678030845c8dc2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fba652ebbcee419b678030845c8dc2
new file mode 100644
index 0000000000000000000000000000000000000000..5f4b708bf54947ee97c05039c8a75811058c8a17
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fba652ebbcee419b678030845c8dc2 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fbee041d19ccda21f4e1bed0b12279 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fbee041d19ccda21f4e1bed0b12279
new file mode 100644
index 0000000000000000000000000000000000000000..80797c791f5c0923d13dc656c844e0e6627081e5
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c4/c4fbee041d19ccda21f4e1bed0b12279 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5077a6b20bfd42d2e4f07c4600151cb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5077a6b20bfd42d2e4f07c4600151cb
new file mode 100644
index 0000000000000000000000000000000000000000..5bcf0acf16026929c9c39130f958b91c20c9eed3
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5077a6b20bfd42d2e4f07c4600151cb differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c524b4ac424f1b42d05b655d43bbce71 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c524b4ac424f1b42d05b655d43bbce71
new file mode 100644
index 0000000000000000000000000000000000000000..cb0941a1eb80e20d0790cc3828bb5c832051ab11
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c524b4ac424f1b42d05b655d43bbce71 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5276bd76e6931901d000e39ffcc2a72 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5276bd76e6931901d000e39ffcc2a72
new file mode 100644
index 0000000000000000000000000000000000000000..9be24013032d4d84da9161c27f8f21bee787110b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5276bd76e6931901d000e39ffcc2a72 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c53fc867a45594f9b1f5f7b01dd9ed0a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c53fc867a45594f9b1f5f7b01dd9ed0a
new file mode 100644
index 0000000000000000000000000000000000000000..1f8f89d566d36a1da1ca5ab1e09d55bb473d33a4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c53fc867a45594f9b1f5f7b01dd9ed0a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c553cffa7715894aec5fb534ec3e7f1e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c553cffa7715894aec5fb534ec3e7f1e
new file mode 100644
index 0000000000000000000000000000000000000000..0e8798436f8f4d748d5104f7068dfb7effd74e90
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c553cffa7715894aec5fb534ec3e7f1e differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c557565886197888c0d76cd47d25aeb5 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c557565886197888c0d76cd47d25aeb5
new file mode 100644
index 0000000000000000000000000000000000000000..a6498433e4e5568f43ff79397c85830523015ac6
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c557565886197888c0d76cd47d25aeb5 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c57a369dcb7fc50ceb888a5d549bed7f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c57a369dcb7fc50ceb888a5d549bed7f
new file mode 100644
index 0000000000000000000000000000000000000000..b0124d6d871d9b786a47aea87a444d27e01a13b1
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c57a369dcb7fc50ceb888a5d549bed7f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5a9a786d1402abc2623d4aae8a7ef12 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5a9a786d1402abc2623d4aae8a7ef12
new file mode 100644
index 0000000000000000000000000000000000000000..60c51ccc0be255a1597f4789179b5009af19de88
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5a9a786d1402abc2623d4aae8a7ef12 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bba5bae4bad7e5135260995803067f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bba5bae4bad7e5135260995803067f
new file mode 100644
index 0000000000000000000000000000000000000000..0b4be0a9905fb2ce64371d5c49c11c6a05fd6a35
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bba5bae4bad7e5135260995803067f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bfbc044119566e26175258777d635d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bfbc044119566e26175258777d635d
new file mode 100644
index 0000000000000000000000000000000000000000..de559a080b4bca4d6a938ab80b06fc2b2008ab3b
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5bfbc044119566e26175258777d635d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5c8135f92c383e19c95dc59a994f0b1 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5c8135f92c383e19c95dc59a994f0b1
new file mode 100644
index 0000000000000000000000000000000000000000..6387fe8b036221f94e3143557d7f079132f34211
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c5/c5c8135f92c383e19c95dc59a994f0b1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c61ff0645367e5c034a6ffcbf6e013cf b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c61ff0645367e5c034a6ffcbf6e013cf
new file mode 100644
index 0000000000000000000000000000000000000000..1dd2dd2e99fb279c467e98a04a689281e64897fa
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c61ff0645367e5c034a6ffcbf6e013cf differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c63959d4bc69aea455cfbfb01a8a1a5a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c63959d4bc69aea455cfbfb01a8a1a5a
new file mode 100644
index 0000000000000000000000000000000000000000..b23607b015cc5dfeacfed855eeaba056aafefbfb
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/c6/c63959d4bc69aea455cfbfb01a8a1a5a differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad3b3b29f2373ced3758c5b2582a59b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad3b3b29f2373ced3758c5b2582a59b
new file mode 100644
index 0000000000000000000000000000000000000000..426c573fc4cb6f4c802ef64b859ad8631c2e514c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad3b3b29f2373ced3758c5b2582a59b differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad79047ee1143fd736665814a3e7d82 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad79047ee1143fd736665814a3e7d82
new file mode 100644
index 0000000000000000000000000000000000000000..3d1eae3d6bae6072ea179a4337edfc87ebae318d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/ca/cad79047ee1143fd736665814a3e7d82 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb2d56fd834f309aea7e62e6f70fe218 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb2d56fd834f309aea7e62e6f70fe218
new file mode 100644
index 0000000000000000000000000000000000000000..87e05a3640d152c2b1b3fb382b62093a7bfadc95
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb2d56fd834f309aea7e62e6f70fe218 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb4eb45474aeeae29b46412ed8fd3d33 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb4eb45474aeeae29b46412ed8fd3d33
new file mode 100644
index 0000000000000000000000000000000000000000..e862a21fee0a496c1cfe886a7714aa3a3af80e1c
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cb/cb4eb45474aeeae29b46412ed8fd3d33 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cc/cc111c28086df096d5dcaf68fba60dac b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cc/cc111c28086df096d5dcaf68fba60dac
new file mode 100644
index 0000000000000000000000000000000000000000..57ab2a42301ca0b866e5463b078420c2c01d7c9d
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/cc/cc111c28086df096d5dcaf68fba60dac differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d40b5978a9047b474bf81dbb09018ab5 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d40b5978a9047b474bf81dbb09018ab5
new file mode 100644
index 0000000000000000000000000000000000000000..7ba3c71c6c745730bd266b382e7edd914eb36d4f
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d40b5978a9047b474bf81dbb09018ab5 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d411e636011f759fd6f4e42e54f2b2a9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d411e636011f759fd6f4e42e54f2b2a9
new file mode 100644
index 0000000000000000000000000000000000000000..ecf9d9b236c700be714c1819f7fc3150ff137ce4
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d411e636011f759fd6f4e42e54f2b2a9 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d436caed4d8d2de570483079fd75cd6f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d436caed4d8d2de570483079fd75cd6f
new file mode 100644
index 0000000000000000000000000000000000000000..4a431ea69174e628d7b746ddf91c3ca833ab5197
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d436caed4d8d2de570483079fd75cd6f differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4388271c5ba406bdfc8be345d91010d b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4388271c5ba406bdfc8be345d91010d
new file mode 100644
index 0000000000000000000000000000000000000000..be3c026c5ab6b9671a1e7873455d79dd6972dff2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4388271c5ba406bdfc8be345d91010d differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d47afa0137e033836e134d0c4d76e25c b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d47afa0137e033836e134d0c4d76e25c
new file mode 100644
index 0000000000000000000000000000000000000000..b0f9ef4133e37334ac669a105e8fe003396ac5cd
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d47afa0137e033836e134d0c4d76e25c differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4a80730b154802ee3879ea702883cbd b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4a80730b154802ee3879ea702883cbd
new file mode 100644
index 0000000000000000000000000000000000000000..053a9b2c3be7ae5c9c0b2cc4a11d4d7c42717869
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/d4/d4a80730b154802ee3879ea702883cbd differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Sprite_columns.PNG b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Sprite_columns.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..aec2253a152939c903499b72e2595438c269fab2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Sprite_columns.PNG differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Visibility_button.PNG b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Visibility_button.PNG
new file mode 100644
index 0000000000000000000000000000000000000000..2c6d31effc4494118f1b9ab099509cda7bc194ab
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Documentation~/images/Visibility_button.PNG differ
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbar.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbar.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..0cc6484d63213fbaee5b815abf219629bfce8bf9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbar.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c1808a8a0e94621468b171839da19a41
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss
new file mode 100644
index 0000000000000000000000000000000000000000..e9b1588da17a6410b7395c724a7fc95e955bf7e8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss
@@ -0,0 +1,63 @@
+/**********************************************************************************************************************/
+/* BoneToolbar                                                                                                         */
+/**********************************************************************************************************************/
+
+#EditPoseImage {
+    background-image: url("Icons/Light/Edit_Pose.png");
+}
+
+#EditJointsImage {
+    background-image: url("Icons/Light/Edit_Joints.png");
+}
+
+#CreateBoneImage {
+    background-image: url("Icons/Light/Create Bones.png");
+}
+
+#SplitBoneImage {
+    background-image: url("Icons/Light/Split Bones.png");
+}
+
+#BoneReparentImage {
+    background-image: url("Icons/Light/Parent_Bone.png");
+}
+
+.Dark #EditPoseImage {
+    background-image: url("Icons/Dark/d_Edit_Pose.png");
+}
+
+.Dark #EditJointsImage {
+    background-image: url("Icons/Dark/d_Edit_Joints.png");
+}
+
+.Dark #CreateBoneImage {
+    background-image: url("Icons/Dark/d_Create Bones.png");
+}
+
+.Dark #SplitBoneImage {
+    background-image: url("Icons/Dark/d_Split Bones.png");
+}
+
+.Dark #BoneReparentImage {
+    background-image: url("Icons/Dark/d_Parent_Bone.png");
+}
+
+.Checked #EditPoseImage{
+    background-image: url("Icons/Selected/Edit_Pose.png");
+}
+
+.Checked #EditJointsImage {
+    background-image: url("Icons/Selected/Edit_Joints.png");
+}
+
+.Checked #CreateBoneImage {
+    background-image: url("Icons/Selected/Create Bones.png");
+}
+
+.Checked #SplitBoneImage {
+    background-image: url("Icons/Selected/Split Bones.png");
+}
+
+.Checked #BoneReparentImage {
+    background-image: url("Icons/Selected/Parent_Bone.png");
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss.meta
new file mode 100644
index 0000000000000000000000000000000000000000..408b8444d2ba4151a987f78f9d4d9e654e4b6ce4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/BoneToolbarStyle.uss.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: d61989f1b8cdf884c960907a37504ceb
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..3d8c3826c37c9a55ef80fe66fdbcae2ca810379b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <aui:CopyToolbar name="CopyToolbar">
+    <ui:Button name="Copy" tooltip="Copy">
+      <ui:Image name="CopyImage" />
+    </ui:Button>
+    <ui:Button name="Paste" tooltip="Paste">
+      <ui:Image name="PasteImage" />
+    </ui:Button>
+  </aui:CopyToolbar>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e43791593ada20c8c2e181a51ab6997b59de2e22
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbar.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acacbd024ec26594a9a9eacba50475d1
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss
new file mode 100644
index 0000000000000000000000000000000000000000..2717a0a39df4954738548b7a82241dbaf4c78ca7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss
@@ -0,0 +1,11 @@
+/**********************************************************************************************************************/
+/* CopyToolbar                                                                                                         */
+/**********************************************************************************************************************/
+
+#CopyImage {
+    background-image: url("Icons/Selected/Copy.png");
+}
+
+#PasteImage {
+    background-image: url("Icons/Selected/Paste.png");
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss.meta
new file mode 100644
index 0000000000000000000000000000000000000000..f4f829b102e74017d59b01338d3f729b4b8fce0d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/CopyToolbarStyle.uss.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 520f059907bcb564dae9203e0969eb59
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/GenerateGeometryPanel.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/GenerateGeometryPanel.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..13eda197a09a97ce14264d4c97f769019e0d316f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/GenerateGeometryPanel.uxml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:eui="UnityEditor.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <aui:GenerateGeometryPanel name="GenerateGeometryPanel" picking-mode="Ignore">
+    <ui:PopupWindow text="Geometry">
+      <ui:VisualElement name="Content">
+        <ui:VisualElement class="form-row">
+          <ui:Label name="OutlineDetailLabel" tooltip="Accuracy of the generated outline. Small values will produce simpler outlines. Large values will produce denser outlines that fit to the Sprite better" text="Outline Detail" />
+          <ui:VisualElement class="form-editor">
+            <ui:Slider name="OutlineDetailSlider" direction="Horizontal" low-value="0" high-value="100" />
+            <eui:IntegerField name="OutlineDetailField" class="slider-field" value="0" />
+          </ui:VisualElement>
+        </ui:VisualElement>
+        <ui:VisualElement class="form-row">
+          <ui:Label name="AlphaToleranceLabel" tooltip="Pixels with alpha value smaller than tolerance will be considered transparent during outline detection" text="Alpha Tolerance" />
+          <ui:VisualElement class="form-editor">
+            <ui:Slider name="AlphaToleranceSlider" direction="Horizontal" low-value="0" high-value="254" />
+            <eui:IntegerField name="AlphaToleranceField" class="slider-field" value="0" />
+          </ui:VisualElement>
+        </ui:VisualElement>
+        <ui:VisualElement class="form-row">
+          <ui:Label name="SubdivideLabel" tooltip="Tesselate the Sprite by adding vertices inside the generated outline" text="Subdivide" />
+          <ui:VisualElement class="form-editor">
+            <ui:Slider name="SubdivideSlider" direction="Horizontal" low-value="0" high-value="100" />
+            <eui:IntegerField name="SubdivideField" class="slider-field" value="0" />
+          </ui:VisualElement>
+        </ui:VisualElement>
+        <ui:VisualElement class="form-row">
+          <ui:Label name="GenerateWeightsLabel" tooltip="Initialize weights automatically for the generated geometry" text="Weights" />
+          <ui:Toggle name="GenerateWeightsField" class="form-editor" value="true" />
+        </ui:VisualElement>
+        <ui:VisualElement class="form-row-space" />
+        <ui:VisualElement name="GenerateSingleSprite" class="form-row">
+          <ui:Button name="GenerateGeometryButton" text="Generate For Selected" tooltip="Generate Geometry for the selected Sprite"/>
+        </ui:VisualElement>
+        <ui:VisualElement name="GenerateMultipleSprite" class="form-row">
+          <ui:Button name="GenerateGeometryAllButton" text="Generate For All Visible" tooltip="Generate Geometry for all the Sprites"/>
+        </ui:VisualElement>
+      </ui:VisualElement>
+    </ui:PopupWindow>
+  </aui:GenerateGeometryPanel>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@2x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@2x.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..a5827a71a4d612ffe0403ac55ab767915d86d9ca
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@2x.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 0779ad3feec52124e97114bcbb12ef13
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 6a3badb5c1034de4192c77c87f1a9426
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@3x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@3x.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..ebc7d7fd929720f5d15ab5f282b8b4fd694ca537
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Bone_Influence@3x.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 68e5a78013e33f247822a837e55b0ab4
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: a38e4657b91eaff48b96a13113f529aa
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Copy.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Copy.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..82a810db732ce63646f3c371568d6c2226befcd2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Copy.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 678095381d851334fb550c5032ba1a81
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 64d2719e2e648de46b0a63f9b7a08a29
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Create_Edge.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Create_Edge.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c36541f599b3d95ba0a65cede4c5fb2a2babe75a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Create_Edge.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: ad7b296d426713b4593ee1a19fcbf9d1
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 952c5ff6177dbd94faa1badcf53c029b
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@4x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@4x.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..0d7afdecd4e6af4b8cc4fbd6fd27317ba870bcb9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Split Bones@4x.png.meta	
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 518ded92e5dbf494e8f76a74d752272e
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 22208bff20f2ab4449e31e867071cbbf
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@3x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@3x.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b99be3e19a40c92a9c5dd362e995b3bfd46a65e4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@3x.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 3e6e6fbbd946d0541923f45f4eaa2cf1
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: c041836bacd58104fa4f67340de8ede6
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@4x.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@4x.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..fa3f6d1d46eaaa342256fc18eda7a7822ee4b6a5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/Icons/Selected/Weight_Brush@4x.png.meta
@@ -0,0 +1,128 @@
+fileFormatVersion: 2
+guid: 48464cd53bb3c604f999e7d3f15e8d09
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 10
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 0
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 0
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: b034bc292c622fc4dae691c8360cc79d
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader
new file mode 100644
index 0000000000000000000000000000000000000000..39eeb541f3dc76e2f23b62242761fb814b1f9668
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader
@@ -0,0 +1,70 @@
+Shader "com.unity3d.animation/SpriteBitmask"
+{
+    Properties
+    {
+        _MainTex("Sprite Texture", 2D) = "white" {}
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue" = "Transparent"
+            "IgnoreProjector" = "True"
+            "RenderType" = "Opaque"
+            "PreviewType" = "Plane"
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        Blend Off
+        ColorMask A
+
+        Pass
+        {
+            CGPROGRAM
+#pragma vertex vert
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color : COLOR;
+                float2 texcoord  : TEXCOORD0;
+            };
+
+            sampler2D _MainTex;
+
+            v2f vert(appdata_t IN)
+            {
+                v2f OUT;
+                OUT.vertex = UnityObjectToClipPos(IN.vertex);
+                OUT.texcoord = IN.texcoord;
+                OUT.color = IN.color;
+                return OUT;
+            }
+
+            fixed4 SampleSpriteTexture(float2 uv)
+            {
+                fixed4 color = tex2D(_MainTex, uv);
+                return color;
+            }
+
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                fixed4 c = SampleSpriteTexture(IN.texcoord);
+                return c;
+            }
+            ENDCG
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader.meta
new file mode 100644
index 0000000000000000000000000000000000000000..805a2035a48f4c82cf41fc95caeec1d5157935a1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBitMask.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3230fdc399f8287488325e5941a00527
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..5e17e0705c4e515fb3b9104bff7c8714a0803ec7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:eui="UnityEditor.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <ui:VisualElement name="Container" picking-modes="Ignore">
+    <ui:Image name ="HeaderImage">
+      <ui:Label name ="HeaderText" text ="Bone Influences"/>
+    </ui:Image>
+
+    <aui:SelectListView name="ListView" itemHeight="20" reorderable="true"/>
+
+    <ui:VisualElement name="ButtonsContainer" picking-mode="Ignore">
+      <ui:Button name="AddButton" tooltip="Add selected bone to influence Sprite">
+      </ui:Button>
+      <ui:Button name="RemoveButton" tooltip="Remove selected bone from influencing Sprite">
+      </ui:Button>
+    </ui:VisualElement>
+  </ui:VisualElement>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..a7c09d25e7d6b7e68db22b97d7fb8f5453f4aa38
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteBoneInfluenceListWidget.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 92fd05e0a13c5e74f8eca8a4beac1fd7
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader
new file mode 100644
index 0000000000000000000000000000000000000000..fa391bb1dd23ed6b591dcf9b1b1e484ec8851f19
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader
@@ -0,0 +1,119 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+Shader "com.unity3d.animation/SpriteOutline"
+{
+    Properties
+    {
+        _MainTex("Sprite Texture", 2D) = "white" {}
+        _OutlineSize("Outline Size", Float) = 1
+        _OutlineColor("Outline Color", Color) = (1,0,1,1)
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue" = "Transparent"
+            "IgnoreProjector" = "True"
+            "RenderType" = "Transparent"
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        Blend SrcAlpha OneMinusSrcAlpha
+
+        Pass
+        {
+            CGPROGRAM
+#pragma vertex vert
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color : COLOR;
+                float2 texcoord  : TEXCOORD0;
+                float2 clipUV : TEXCOORD1;
+            };
+
+            float _Outline;
+            fixed4 _OutlineColor;
+            uniform float4 _MainTex_ST;
+            uniform float4x4 unity_GUIClipTextureMatrix;
+            uniform bool _AdjustLinearForGamma;
+            sampler2D _GUIClipTexture;
+            v2f vert(appdata_t IN)
+            {
+                v2f OUT;
+                OUT.vertex = UnityObjectToClipPos(IN.vertex);
+                OUT.texcoord = TRANSFORM_TEX(IN.texcoord, _MainTex);
+                OUT.color = IN.color;
+                float3 eyePos = UnityObjectToViewPos(IN.vertex);
+                OUT.clipUV = mul(unity_GUIClipTextureMatrix, float4(eyePos.xy, 0, 1.0));
+
+                return OUT;
+            }
+
+            sampler2D _MainTex;
+            sampler2D _AlphaTex;
+            float4 _MainTex_TexelSize;
+            fixed _OutlineSize;
+            fixed4 _ObjectSize;
+
+            fixed4 frag(v2f i) : SV_Target
+            {
+                if (tex2D(_GUIClipTexture, i.clipUV).a == 0)
+                    discard;
+
+                float width = _OutlineSize*_MainTex_TexelSize.x;
+                float height = _OutlineSize*_MainTex_TexelSize.y;
+
+                float2 texPos = i.texcoord + float2(-width, -height);
+                half a1 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+                texPos = i.texcoord + float2(0, -height);
+                half a2 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+                texPos = i.texcoord + float2(+width, -height);
+                half a3 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+
+                texPos = i.texcoord + float2(-width, 0);
+                half a4 =texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+                texPos = i.texcoord + float2(+width, 0);
+                half a6 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+
+                texPos = i.texcoord + float2(-width, +height);
+                half a7 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+                texPos = i.texcoord + float2(0, +height);
+                half a8 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+                texPos = i.texcoord + float2(+width, +height);
+                half a9 = texPos.x >= 0 && texPos.y >= 0 && texPos.x <= 1 && texPos.y <= 1 ? tex2D(_MainTex, texPos).a : 0;
+
+                half gx = -a1 - a2  - a3 + a7 + a8  + a9;
+                half gy = -a1 - a4  - a7 + a3 + a6  + a9;
+
+                half w = sqrt(gx * gx + gy * gy) * 1.25;
+
+                float4 c = _OutlineColor;
+                if (w >= 1)
+                {
+                    if (_AdjustLinearForGamma)
+                        c.rgb = LinearToGammaSpace(c.rgb);
+                }
+                else
+                    discard;
+
+                return c;
+
+            }
+            ENDCG
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b8e062118daaaab4fd1c932ec9ffb53cbb76d025
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/SpriteOutline.shader.meta
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0a8f4dcd626bcd14bbbfa5a5e116b16e
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..5ce850e4cc4ae1453e03d0898f806479ede2d8c9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:eui="UnityEditor.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <aui:VisibilityToolWindow name="VisibilityToolWindow" picking-mode="Ignore">
+    <ui:PopupWindow name="PopupWindow" text="Visibility">
+        <ui:VisualElement name="OpacitySliderGroup">
+            <ui:VisualElement name="BoneOpacitySliderGroup" >
+                <ui:Image name="BoneOpacitySliderIcon" tool-tip = "Adjust Bone opacity"/>
+                <ui:Slider name ="BoneOpacitySlider" low-value ="0" high-value="1" direction="Horizontal" tool-tip = "Adjust Bone opacity"/>
+            </ui:VisualElement>
+            <ui:VisualElement name="MeshOpacitySliderGroup">
+                <ui:Image name="MeshOpacitySliderIcon" tool-tip =" Adjust Weight opacity"/>
+                <ui:Slider name ="MeshOpacitySlider" low-value ="0" high-value="1" direction="Horizontal" tool-tip =" Adjust Weight opacity"/>
+            </ui:VisualElement>
+        </ui:VisualElement>
+      <ui:VisualElement name ="VisibilityToolSelection" />
+      <ui:VisualElement name ="VisibilityToolContainer" />
+    </ui:PopupWindow>
+    <ui:VisualElement name="Resizer"/>
+  </aui:VisibilityToolWindow>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..1c5efd07773eb1b08f58b5d3da61d7d4f984346f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolWindow.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c5cb5d0bb89666419fa44a3e64ed366
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..41f0d9ed4cdae0e30a595c1f471e515a9ff194ed
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <aui:Toolbar name="VisibilityToolbar">
+    <ui:Button name="VisibilityToolButton" tooltip="Visibility Tool">
+      <ui:Image name="HierarchyToolButtonImage" />
+    </ui:Button>
+  </aui:Toolbar>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7c157cdb27e8038379de261acb0eed3cbb597726
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/VisibilityToolbar.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2cea33b1d0032174c8833d64fbf31529
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss
new file mode 100644
index 0000000000000000000000000000000000000000..4307be175f0b709e18f0bcf27b3c07ff12d9039d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss
@@ -0,0 +1,11 @@
+/**********************************************************************************************************************/
+/* WeightInspectorIMGUIPanel                                                                                                         */
+/**********************************************************************************************************************/
+
+#WeightInspectorIMGUIPanel {
+  flex-direction: column;
+  height: 120px;
+}
+
+#WeightInspectorIMGUIPanel IMGUIContainer {
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss.meta
new file mode 100644
index 0000000000000000000000000000000000000000..886e5b42d1b215ae81edcaef7a30db5046d4e0f2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightInspectorIMGUIPanelStyle.uss.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 31c817456951a8b4f9c5a038f633223c
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: stylesheet
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml
new file mode 100644
index 0000000000000000000000000000000000000000..0d74711b208980a1b3108b9fd84a208130c8cb19
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<UXML xmlns:ui="UnityEngine.UIElements" xmlns:eui="UnityEditor.UIElements" xmlns:aui="UnityEditor.U2D.Animation">
+  <aui:WeightPainterPanel name="WeightPainterPanel" text="Weight Painter" picking-mode="Ignore">
+    <ui:PopupWindow text="Weight Painter">
+      <ui:VisualElement name ="BrushModeField" class="form-row">
+        <ui:VisualElement class="form-popup" name="Mode" />
+        <!-- No support for Enums outside of UnityEditor -->
+        <!-- <eui:EnumField name="ModeField" type="WeightEditorMode" /> -->
+      </ui:VisualElement>
+      <ui:VisualElement name="Bone" class="form-row">
+        <ui:VisualElement class="form-popup" name="BoneEnumPopup" />
+        <!-- No factory method for PopupField here -->
+      </ui:VisualElement>
+
+      <ui:VisualElement class="form-row">
+        <ui:Toggle name="NormalizeToggle" class="form-toggle" value="true" tooltip="Normalize weights after each edit" label="Normalize" />
+      </ui:VisualElement>
+
+      <ui:VisualElement name="Size" class="form-row">
+        <eui:IntegerField name="SizeField" class="form-integerfield" value="25" label="Size" tooltip ="Brush size"/>
+      </ui:VisualElement>
+
+      <ui:VisualElement name="Amount" class="form-row">
+        <ui:Label name="AmountLabel" text="Amount" tooltip ="Weight amount"/>
+        <ui:VisualElement class="form-editor">
+          <ui:Slider name="AmountSlider" direction="Horizontal" low-value="-1" high-value="1" />
+          <eui:FloatField name="AmountField" class="slider-field" value="0" />
+        </ui:VisualElement>
+      </ui:VisualElement>
+        <ui:VisualElement name="divider" />
+        <aui:WeightInspectorIMGUIPanel name ="WeightsInspector" />
+      <ui:VisualElement name="Hardness" class="form-row">
+        <ui:Label name="HardnessLabel" text="Hardness" tooltip ="Brush hardness"/>
+        <ui:VisualElement class="form-editor">
+          <ui:Slider name="HardnessSlider" direction="Horizontal" low-value="1" high-value="100" />
+          <eui:IntegerField name="HardnessField" class="slider-field" value="1" />
+        </ui:VisualElement>
+      </ui:VisualElement>
+      <ui:VisualElement name="Step" class="form-row">
+        <ui:Label name="StepLabel" text="Step" tooltip ="Brush step size"/>
+        <ui:VisualElement class="form-editor">
+          <ui:Slider name="StepSlider" direction="Horizontal" low-value="1" high-value="100" />
+          <eui:IntegerField name="StepField" class="slider-field" value="1" />
+        </ui:VisualElement>
+      </ui:VisualElement>
+    </ui:PopupWindow>
+  </aui:WeightPainterPanel>
+</UXML>
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5b4a7767de9b47bb352c1bc0b311f039b780f4fe
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/WeightPainterPanel.uxml.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e9568834ba2b2c44af4e3876cee0d2d
+ScriptedImporter:
+  fileIDToRecycleName:
+    11400000: tree
+    11400002: inlineStyle
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotCyan.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotCyan.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b7885ffb200810d3595f615034af2af9aa2642ae
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotCyan.png.meta
@@ -0,0 +1,131 @@
+fileFormatVersion: 2
+guid: 5b56cb1a6bd97f348b3a3b6f875aafd6
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: c888c25207532a945bdab1cb4bdab636
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotYellow.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotYellow.png.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7450f7b27ef372271ec85ebaf3c29d464fb4a8c7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Assets/SkinningModule/dotYellow.png.meta
@@ -0,0 +1,131 @@
+fileFormatVersion: 2
+guid: 173a5eb1d13d68d4ea39f3e5d2c6e2c0
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: tvOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - buildTarget: Nintendo Switch
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: fd976353bf1229e4b87a6aed8e4e3322
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs
new file mode 100644
index 0000000000000000000000000000000000000000..9dd720c2a64a993602c161737fd31e7de15c5cd8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs
@@ -0,0 +1,4913 @@
+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  6.4.2                                                           *
+* Date      :  27 February 2017                                                *
+* Website   :  http://www.angusj.com                                           *
+* Copyright :  Angus Johnson 2010-2017                                         *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+* See also:                                                                    *
+* "Polygon Offsetting by Computing Winding Numbers"                            *
+* Paper no. DETC2005-85513 pp. 565-575                                         *
+* ASME 2005 International Design Engineering Technical Conferences             *
+* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+* September 24-28, 2005 , Long Beach, California, USA                          *
+* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
+*                                                                              *
+*******************************************************************************/
+
+/*******************************************************************************
+*                                                                              *
+* This is a translation of the Delphi Clipper library and the naming style     *
+* used has retained a Delphi flavour.                                          *
+*                                                                              *
+*******************************************************************************/
+
+//use_int32: When enabled 32bit ints are used instead of 64bit ints. This
+//improve performance but coordinate values are limited to the range +/- 46340
+//#define use_int32
+
+//use_xyz: adds a Z member to IntPoint. Adds a minor cost to performance.
+//#define use_xyz
+
+//use_lines: Enables open path clipping. Adds a very minor cost to performance.
+#define use_lines
+
+
+using System;
+using System.Collections.Generic;
+//using System.Text;          //for Int128.AsString() & StringBuilder
+//using System.IO;            //debugging with streamReader & StreamWriter
+//using System.Windows.Forms; //debugging to clipboard
+
+namespace UnityEditor.U2D.Animation.ClipperLib
+{
+
+#if use_int32
+  using cInt = Int32;
+#else
+  using cInt = Int64;
+#endif
+
+  using Path = List<IntPoint>;
+  using Paths = List<List<IntPoint>>;
+
+  internal struct DoublePoint
+  {
+    public double X;
+    public double Y;
+
+    public DoublePoint(double x = 0, double y = 0)
+    {
+      this.X = x; this.Y = y;
+    }
+    public DoublePoint(DoublePoint dp)
+    {
+      this.X = dp.X; this.Y = dp.Y;
+    }
+    public DoublePoint(IntPoint ip)
+    {
+      this.X = ip.X; this.Y = ip.Y;
+    }
+  };
+
+
+  //------------------------------------------------------------------------------
+  // PolyTree & PolyNode classes
+  //------------------------------------------------------------------------------
+
+  internal class PolyTree : PolyNode
+  {
+      internal List<PolyNode> m_AllPolys = new List<PolyNode>();
+
+      //The GC probably handles this cleanup more efficiently ...
+      //~PolyTree(){Clear();}
+        
+      public void Clear() 
+      {
+          for (int i = 0; i < m_AllPolys.Count; i++)
+              m_AllPolys[i] = null;
+          m_AllPolys.Clear(); 
+          m_Childs.Clear(); 
+      }
+        
+      public PolyNode GetFirst()
+      {
+          if (m_Childs.Count > 0)
+              return m_Childs[0];
+          else
+              return null;
+      }
+
+      public int Total
+      {
+          get 
+          { 
+            int result = m_AllPolys.Count;
+            //with negative offsets, ignore the hidden outer polygon ...
+            if (result > 0 && m_Childs[0] != m_AllPolys[0]) result--;
+            return result;
+          }
+      }
+
+  }
+        
+  internal class PolyNode 
+  {
+      internal PolyNode m_Parent;
+      internal Path m_polygon = new Path();
+      internal int m_Index;
+      internal JoinType m_jointype;
+      internal EndType m_endtype;
+      internal List<PolyNode> m_Childs = new List<PolyNode>();
+
+      private bool IsHoleNode()
+      {
+          bool result = true;
+          PolyNode node = m_Parent;
+          while (node != null)
+          {
+              result = !result;
+              node = node.m_Parent;
+          }
+          return result;
+      }
+
+      public int ChildCount
+      {
+          get { return m_Childs.Count; }
+      }
+
+      public Path Contour
+      {
+          get { return m_polygon; }
+      }
+
+      internal void AddChild(PolyNode Child)
+      {
+          int cnt = m_Childs.Count;
+          m_Childs.Add(Child);
+          Child.m_Parent = this;
+          Child.m_Index = cnt;
+      }
+
+      public PolyNode GetNext()
+      {
+          if (m_Childs.Count > 0) 
+              return m_Childs[0]; 
+          else
+              return GetNextSiblingUp();        
+      }
+  
+      internal PolyNode GetNextSiblingUp()
+      {
+          if (m_Parent == null)
+              return null;
+          else if (m_Index == m_Parent.m_Childs.Count - 1)
+              return m_Parent.GetNextSiblingUp();
+          else
+              return m_Parent.m_Childs[m_Index + 1];
+      }
+
+      public List<PolyNode> Childs
+      {
+          get { return m_Childs; }
+      }
+
+      public PolyNode Parent
+      {
+          get { return m_Parent; }
+      }
+
+      public bool IsHole
+      {
+          get { return IsHoleNode(); }
+      }
+
+      public bool IsOpen { get; set; }
+  }
+
+
+  //------------------------------------------------------------------------------
+  // Int128 struct (enables safe math on signed 64bit integers)
+  // eg Int128 val1((Int64)9223372036854775807); //ie 2^63 -1
+  //    Int128 val2((Int64)9223372036854775807);
+  //    Int128 val3 = val1 * val2;
+  //    val3.ToString => "85070591730234615847396907784232501249" (8.5e+37)
+  //------------------------------------------------------------------------------
+
+  internal struct Int128
+  {
+    private Int64 hi;
+    private UInt64 lo;
+
+    public Int128(Int64 _lo)
+    {
+      lo = (UInt64)_lo;
+      if (_lo < 0) hi = -1;
+      else hi = 0;
+    }
+
+    public Int128(Int64 _hi, UInt64 _lo)
+    {
+      lo = _lo;
+      hi = _hi;
+    }
+
+    public Int128(Int128 val)
+    {
+      hi = val.hi;
+      lo = val.lo;
+    }
+
+    public bool IsNegative()
+    {
+      return hi < 0;
+    }
+
+    public static bool operator ==(Int128 val1, Int128 val2)
+    {
+      if ((object)val1 == (object)val2) return true;
+      else if ((object)val1 == null || (object)val2 == null) return false;
+      return (val1.hi == val2.hi && val1.lo == val2.lo);
+    }
+
+    public static bool operator !=(Int128 val1, Int128 val2)
+    {
+      return !(val1 == val2);
+    }
+
+    public override bool Equals(System.Object obj)
+    {
+      if (obj == null || !(obj is Int128))
+        return false;
+      Int128 i128 = (Int128)obj;
+      return (i128.hi == hi && i128.lo == lo);
+    }
+
+    public override int GetHashCode()
+    {
+      return hi.GetHashCode() ^ lo.GetHashCode();
+    }
+
+    public static bool operator >(Int128 val1, Int128 val2)
+    {
+      if (val1.hi != val2.hi)
+        return val1.hi > val2.hi;
+      else
+        return val1.lo > val2.lo;
+    }
+
+    public static bool operator <(Int128 val1, Int128 val2)
+    {
+      if (val1.hi != val2.hi)
+        return val1.hi < val2.hi;
+      else
+        return val1.lo < val2.lo;
+    }
+
+    public static Int128 operator +(Int128 lhs, Int128 rhs)
+    {
+      lhs.hi += rhs.hi;
+      lhs.lo += rhs.lo;
+      if (lhs.lo < rhs.lo) lhs.hi++;
+      return lhs;
+    }
+
+    public static Int128 operator -(Int128 lhs, Int128 rhs)
+    {
+      return lhs + -rhs;
+    }
+
+    public static Int128 operator -(Int128 val)
+    {
+      if (val.lo == 0)
+        return new Int128(-val.hi, 0);
+      else
+        return new Int128(~val.hi, ~val.lo + 1);
+    }
+
+    public static explicit operator double(Int128 val)
+    {
+      const double shift64 = 18446744073709551616.0; //2^64
+      if (val.hi < 0)
+      {
+        if (val.lo == 0)
+          return (double)val.hi * shift64;
+        else
+          return -(double)(~val.lo + ~val.hi * shift64);
+      }
+      else
+        return (double)(val.lo + val.hi * shift64);
+    }
+    
+    //nb: Constructing two new Int128 objects every time we want to multiply longs  
+    //is slow. So, although calling the Int128Mul method doesn't look as clean, the 
+    //code runs significantly faster than if we'd used the * operator.
+
+    public static Int128 Int128Mul(Int64 lhs, Int64 rhs)
+    {
+      bool negate = (lhs < 0) != (rhs < 0);
+      if (lhs < 0) lhs = -lhs;
+      if (rhs < 0) rhs = -rhs;
+      UInt64 int1Hi = (UInt64)lhs >> 32;
+      UInt64 int1Lo = (UInt64)lhs & 0xFFFFFFFF;
+      UInt64 int2Hi = (UInt64)rhs >> 32;
+      UInt64 int2Lo = (UInt64)rhs & 0xFFFFFFFF;
+
+      //nb: see comments in clipper.pas
+      UInt64 a = int1Hi * int2Hi;
+      UInt64 b = int1Lo * int2Lo;
+      UInt64 c = int1Hi * int2Lo + int1Lo * int2Hi;
+
+      UInt64 lo;
+      Int64 hi;
+      hi = (Int64)(a + (c >> 32));
+
+      unchecked { lo = (c << 32) + b; }
+      if (lo < b) hi++;
+      Int128 result = new Int128(hi, lo);
+      return negate ? -result : result;
+    }
+
+  };
+
+  //------------------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  internal struct IntPoint
+  {
+    public cInt X;
+    public cInt Y;
+#if use_xyz
+    public cInt Z;
+    
+    public IntPoint(cInt x, cInt y, cInt z = 0)
+    {
+      this.X = x; this.Y = y; this.Z = z;
+    }
+    
+    public IntPoint(double x, double y, double z = 0)
+    {
+      this.X = (cInt)x; this.Y = (cInt)y; this.Z = (cInt)z;
+    }
+    
+    public IntPoint(DoublePoint dp)
+    {
+      this.X = (cInt)dp.X; this.Y = (cInt)dp.Y; this.Z = 0;
+    }
+
+    public IntPoint(IntPoint pt)
+    {
+      this.X = pt.X; this.Y = pt.Y; this.Z = pt.Z;
+    }
+#else
+    public IntPoint(cInt X, cInt Y)
+    {
+        this.X = X; this.Y = Y;
+    }
+    public IntPoint(double x, double y)
+    {
+      this.X = (cInt)x; this.Y = (cInt)y;
+    }
+
+    public IntPoint(IntPoint pt)
+    {
+        this.X = pt.X; this.Y = pt.Y;
+    }
+#endif
+
+    public static bool operator ==(IntPoint a, IntPoint b)
+    {
+      return a.X == b.X && a.Y == b.Y;
+    }
+
+    public static bool operator !=(IntPoint a, IntPoint b)
+    {
+      return a.X != b.X  || a.Y != b.Y; 
+    }
+
+    public override bool Equals(object obj)
+    {
+      if (obj == null) return false;
+      if (obj is IntPoint)
+      {
+        IntPoint a = (IntPoint)obj;
+        return (X == a.X) && (Y == a.Y);
+      }
+      else return false;
+    }
+
+    public override int GetHashCode()
+    {
+      //simply prevents a compiler warning
+      return base.GetHashCode();
+    }
+
+  }// end struct IntPoint
+
+  internal struct IntRect
+  {
+    public cInt left;
+    public cInt top;
+    public cInt right;
+    public cInt bottom;
+
+    public IntRect(cInt l, cInt t, cInt r, cInt b)
+    {
+      this.left = l; this.top = t;
+      this.right = r; this.bottom = b;
+    }
+    public IntRect(IntRect ir)
+    {
+      this.left = ir.left; this.top = ir.top;
+      this.right = ir.right; this.bottom = ir.bottom;
+    }
+  }
+
+  internal enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+  internal enum PolyType { ptSubject, ptClip };
+  
+  //By far the most widely used winding rules for polygon filling are
+  //EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
+  //Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
+  //see http://glprogramming.com/red/chapter11.html
+  internal enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+  
+  internal enum JoinType { jtSquare, jtRound, jtMiter };
+  internal enum EndType { etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound };
+
+  internal enum EdgeSide {esLeft, esRight};
+  internal enum Direction {dRightToLeft, dLeftToRight};
+    
+  internal class TEdge {
+    internal IntPoint Bot;
+    internal IntPoint Curr; //current (updated for every new scanbeam)
+    internal IntPoint Top;
+    internal IntPoint Delta;
+    internal double Dx;
+    internal PolyType PolyTyp;
+    internal EdgeSide Side; //side only refers to current side of solution poly
+    internal int WindDelta; //1 or -1 depending on winding direction
+    internal int WindCnt;
+    internal int WindCnt2; //winding count of the opposite polytype
+    internal int OutIdx;
+    internal TEdge Next;
+    internal TEdge Prev;
+    internal TEdge NextInLML;
+    internal TEdge NextInAEL;
+    internal TEdge PrevInAEL;
+    internal TEdge NextInSEL;
+    internal TEdge PrevInSEL;
+  };
+
+  internal class IntersectNode
+  {
+      internal TEdge Edge1;
+      internal TEdge Edge2;
+      internal IntPoint Pt;
+  };
+
+  internal class MyIntersectNodeSort : IComparer<IntersectNode>
+  {
+    public int Compare(IntersectNode node1, IntersectNode node2)
+    {
+      cInt i = node2.Pt.Y - node1.Pt.Y;
+      if (i > 0) return 1;
+      else if (i < 0) return -1;
+      else return 0;
+    }
+  }
+
+  internal class LocalMinima
+  {
+    internal cInt Y;
+    internal TEdge LeftBound;
+    internal TEdge RightBound;
+    internal LocalMinima Next;
+  };
+
+  internal class Scanbeam
+  {
+      internal cInt Y;
+      internal Scanbeam Next;
+  };
+
+  internal class Maxima
+  {
+      internal cInt X;
+      internal Maxima Next;
+      internal Maxima Prev;
+  };
+
+  //OutRec: contains a path in the clipping solution. Edges in the AEL will
+  //carry a pointer to an OutRec when they are part of the clipping solution.
+  internal class OutRec
+  {
+    internal int Idx;
+    internal bool IsHole;
+    internal bool IsOpen;
+    internal OutRec FirstLeft; //see comments in clipper.pas
+    internal OutPt Pts;
+    internal OutPt BottomPt;
+    internal PolyNode PolyNode;
+  };
+
+  internal class OutPt
+  {
+    internal int Idx;
+    internal IntPoint Pt;
+    internal OutPt Next;
+    internal OutPt Prev;
+  };
+
+  internal class Join
+  {
+    internal OutPt OutPt1;
+    internal OutPt OutPt2;
+    internal IntPoint OffPt;
+  };
+
+  internal class ClipperBase
+  {    
+    internal const double horizontal = -3.4E+38;
+    internal const int Skip = -2;
+    internal const int Unassigned = -1;
+    internal const double tolerance = 1.0E-20;
+    internal static bool near_zero(double val){return (val > -tolerance) && (val < tolerance);}
+
+#if use_int32
+    public const cInt loRange = 0x7FFF;
+    public const cInt hiRange = 0x7FFF;
+#else
+    public const cInt loRange = 0x3FFFFFFF;
+    public const cInt hiRange = 0x3FFFFFFFFFFFFFFFL; 
+#endif
+
+    internal LocalMinima m_MinimaList;
+    internal LocalMinima m_CurrentLM;
+    internal List<List<TEdge>> m_edges = new List<List<TEdge>>();
+    internal Scanbeam m_Scanbeam;
+    internal List<OutRec> m_PolyOuts;
+    internal TEdge m_ActiveEdges;
+    internal bool m_UseFullRange;
+    internal bool m_HasOpenPaths;
+
+    //------------------------------------------------------------------------------
+
+    public bool PreserveCollinear
+    {
+      get;
+      set;
+    }
+    //------------------------------------------------------------------------------
+
+    public void Swap(ref cInt val1, ref cInt val2)
+    {
+      cInt tmp = val1;
+      val1 = val2;
+      val2 = tmp;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool IsHorizontal(TEdge e)
+    {
+      return e.Delta.Y == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointIsVertex(IntPoint pt, OutPt pp)
+    {
+      OutPt pp2 = pp;
+      do
+      {
+        if (pp2.Pt == pt) return true;
+        pp2 = pp2.Next;
+      }
+      while (pp2 != pp);
+      return false;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointOnLineSegment(IntPoint pt, 
+        IntPoint linePt1, IntPoint linePt2, bool UseFullRange)
+    {
+      if (UseFullRange)
+        return ((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) ||
+          ((pt.X == linePt2.X) && (pt.Y == linePt2.Y)) ||
+          (((pt.X > linePt1.X) == (pt.X < linePt2.X)) &&
+          ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y)) &&
+          ((Int128.Int128Mul((pt.X - linePt1.X), (linePt2.Y - linePt1.Y)) ==
+          Int128.Int128Mul((linePt2.X - linePt1.X), (pt.Y - linePt1.Y)))));
+      else
+        return ((pt.X == linePt1.X) && (pt.Y == linePt1.Y)) ||
+          ((pt.X == linePt2.X) && (pt.Y == linePt2.Y)) ||
+          (((pt.X > linePt1.X) == (pt.X < linePt2.X)) &&
+          ((pt.Y > linePt1.Y) == (pt.Y < linePt2.Y)) &&
+          ((pt.X - linePt1.X) * (linePt2.Y - linePt1.Y) ==
+            (linePt2.X - linePt1.X) * (pt.Y - linePt1.Y)));
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool PointOnPolygon(IntPoint pt, OutPt pp, bool UseFullRange)
+    {
+      OutPt pp2 = pp;
+      while (true)
+      {
+        if (PointOnLineSegment(pt, pp2.Pt, pp2.Next.Pt, UseFullRange))
+          return true;
+        pp2 = pp2.Next;
+        if (pp2 == pp) break;
+      }
+      return false;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(TEdge e1, TEdge e2, bool UseFullRange)
+    {
+        if (UseFullRange)
+          return Int128.Int128Mul(e1.Delta.Y, e2.Delta.X) ==
+              Int128.Int128Mul(e1.Delta.X, e2.Delta.Y);
+        else return (cInt)(e1.Delta.Y) * (e2.Delta.X) ==
+          (cInt)(e1.Delta.X) * (e2.Delta.Y);
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(IntPoint pt1, IntPoint pt2,
+        IntPoint pt3, bool UseFullRange)
+    {
+        if (UseFullRange)
+            return Int128.Int128Mul(pt1.Y - pt2.Y, pt2.X - pt3.X) ==
+              Int128.Int128Mul(pt1.X - pt2.X, pt2.Y - pt3.Y);
+        else return
+          (cInt)(pt1.Y - pt2.Y) * (pt2.X - pt3.X) - (cInt)(pt1.X - pt2.X) * (pt2.Y - pt3.Y) == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static bool SlopesEqual(IntPoint pt1, IntPoint pt2,
+        IntPoint pt3, IntPoint pt4, bool UseFullRange)
+    {
+        if (UseFullRange)
+            return Int128.Int128Mul(pt1.Y - pt2.Y, pt3.X - pt4.X) ==
+              Int128.Int128Mul(pt1.X - pt2.X, pt3.Y - pt4.Y);
+        else return
+          (cInt)(pt1.Y - pt2.Y) * (pt3.X - pt4.X) - (cInt)(pt1.X - pt2.X) * (pt3.Y - pt4.Y) == 0;
+    }
+    //------------------------------------------------------------------------------
+
+    internal ClipperBase() //constructor (nb: no external instantiation)
+    {
+        m_MinimaList = null;
+        m_CurrentLM = null;
+        m_UseFullRange = false;
+        m_HasOpenPaths = false;
+    }
+    //------------------------------------------------------------------------------
+
+    public virtual void Clear()
+    {
+        DisposeLocalMinimaList();
+        for (int i = 0; i < m_edges.Count; ++i)
+        {
+            for (int j = 0; j < m_edges[i].Count; ++j) m_edges[i][j] = null;
+            m_edges[i].Clear();
+        }
+        m_edges.Clear();
+        m_UseFullRange = false;
+        m_HasOpenPaths = false;
+    }
+    //------------------------------------------------------------------------------
+
+    private void DisposeLocalMinimaList()
+    {
+        while( m_MinimaList != null )
+        {
+            LocalMinima tmpLm = m_MinimaList.Next;
+            m_MinimaList = null;
+            m_MinimaList = tmpLm;
+        }
+        m_CurrentLM = null;
+    }
+    //------------------------------------------------------------------------------
+
+    void RangeTest(IntPoint Pt, ref bool useFullRange)
+    {
+      if (useFullRange)
+      {
+        if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange) 
+          throw new ClipperException("Coordinate outside allowed range");
+      }
+      else if (Pt.X > loRange || Pt.Y > loRange || -Pt.X > loRange || -Pt.Y > loRange) 
+      {
+        useFullRange = true;
+        RangeTest(Pt, ref useFullRange);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    private void InitEdge(TEdge e, TEdge eNext,
+      TEdge ePrev, IntPoint pt)
+    {
+      e.Next = eNext;
+      e.Prev = ePrev;
+      e.Curr = pt;
+      e.OutIdx = Unassigned;
+    }
+    //------------------------------------------------------------------------------
+
+    private void InitEdge2(TEdge e, PolyType polyType)
+    {
+      if (e.Curr.Y >= e.Next.Curr.Y)
+      {
+        e.Bot = e.Curr;
+        e.Top = e.Next.Curr;
+      }
+      else
+      {
+        e.Top = e.Curr;
+        e.Bot = e.Next.Curr;
+      }
+      SetDx(e);
+      e.PolyTyp = polyType;
+    }
+    //------------------------------------------------------------------------------
+
+    private TEdge FindNextLocMin(TEdge E)
+    {
+      TEdge E2;
+      for (;;)
+      {
+        while (E.Bot != E.Prev.Bot || E.Curr == E.Top) E = E.Next;
+        if (E.Dx != horizontal && E.Prev.Dx != horizontal) break;
+        while (E.Prev.Dx == horizontal) E = E.Prev;
+        E2 = E;
+        while (E.Dx == horizontal) E = E.Next;
+        if (E.Top.Y == E.Prev.Bot.Y) continue; //ie just an intermediate horz.
+        if (E2.Prev.Bot.X < E.Bot.X) E = E2;
+        break;
+      }
+      return E;
+    }
+    //------------------------------------------------------------------------------
+
+    private TEdge ProcessBound(TEdge E, bool LeftBoundIsForward)
+    {
+      TEdge EStart, Result = E;
+      TEdge Horz;
+
+      if (Result.OutIdx == Skip)
+      {
+        //check if there are edges beyond the skip edge in the bound and if so
+        //create another LocMin and calling ProcessBound once more ...
+        E = Result;
+        if (LeftBoundIsForward)
+        {
+          while (E.Top.Y == E.Next.Bot.Y) E = E.Next;
+          while (E != Result && E.Dx == horizontal) E = E.Prev;
+        }
+        else
+        {
+          while (E.Top.Y == E.Prev.Bot.Y) E = E.Prev;
+          while (E != Result && E.Dx == horizontal) E = E.Next;
+        }
+        if (E == Result)
+        {
+          if (LeftBoundIsForward) Result = E.Next;
+          else Result = E.Prev;
+        }
+        else
+        {
+          //there are more edges in the bound beyond result starting with E
+          if (LeftBoundIsForward)
+            E = Result.Next;
+          else
+            E = Result.Prev;
+          LocalMinima locMin = new LocalMinima();
+          locMin.Next = null;
+          locMin.Y = E.Bot.Y;
+          locMin.LeftBound = null;
+          locMin.RightBound = E;
+          E.WindDelta = 0;
+          Result = ProcessBound(E, LeftBoundIsForward);
+          InsertLocalMinima(locMin);
+        }
+        return Result;
+      }
+
+      if (E.Dx == horizontal)
+      {
+        //We need to be careful with open paths because this may not be a
+        //true local minima (ie E may be following a skip edge).
+        //Also, consecutive horz. edges may start heading left before going right.
+        if (LeftBoundIsForward) EStart = E.Prev;
+        else EStart = E.Next;
+        if (EStart.Dx == horizontal) //ie an adjoining horizontal skip edge
+        {
+        if (EStart.Bot.X != E.Bot.X && EStart.Top.X != E.Bot.X)
+            ReverseHorizontal(E);
+        }
+        else if (EStart.Bot.X != E.Bot.X)
+        ReverseHorizontal(E);
+      }
+
+      EStart = E;
+      if (LeftBoundIsForward)
+      {
+        while (Result.Top.Y == Result.Next.Bot.Y && Result.Next.OutIdx != Skip)
+          Result = Result.Next;
+        if (Result.Dx == horizontal && Result.Next.OutIdx != Skip)
+        {
+          //nb: at the top of a bound, horizontals are added to the bound
+          //only when the preceding edge attaches to the horizontal's left vertex
+          //unless a Skip edge is encountered when that becomes the top divide
+          Horz = Result;
+          while (Horz.Prev.Dx == horizontal) Horz = Horz.Prev;
+          if (Horz.Prev.Top.X > Result.Next.Top.X) Result = Horz.Prev;
+        }
+        while (E != Result)
+        {
+          E.NextInLML = E.Next;
+          if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Prev.Top.X) 
+            ReverseHorizontal(E);
+          E = E.Next;
+        }
+        if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Prev.Top.X) 
+          ReverseHorizontal(E);
+        Result = Result.Next; //move to the edge just beyond current bound
+      }
+      else
+      {
+        while (Result.Top.Y == Result.Prev.Bot.Y && Result.Prev.OutIdx != Skip)
+          Result = Result.Prev;
+        if (Result.Dx == horizontal && Result.Prev.OutIdx != Skip)
+        {
+          Horz = Result;
+          while (Horz.Next.Dx == horizontal) Horz = Horz.Next;
+          if (Horz.Next.Top.X == Result.Prev.Top.X || 
+              Horz.Next.Top.X > Result.Prev.Top.X) Result = Horz.Next;
+        }
+
+        while (E != Result)
+        {
+          E.NextInLML = E.Prev;
+          if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Next.Top.X) 
+            ReverseHorizontal(E);
+          E = E.Prev;
+        }
+        if (E.Dx == horizontal && E != EStart && E.Bot.X != E.Next.Top.X) 
+          ReverseHorizontal(E);
+        Result = Result.Prev; //move to the edge just beyond current bound
+      }
+      return Result;
+    }
+    //------------------------------------------------------------------------------
+
+
+    public bool AddPath(Path pg, PolyType polyType, bool Closed)
+    {
+#if use_lines
+      if (!Closed && polyType == PolyType.ptClip)
+        throw new ClipperException("AddPath: Open paths must be subject.");
+#else
+      if (!Closed)
+        throw new ClipperException("AddPath: Open paths have been disabled.");
+#endif
+
+      int highI = (int)pg.Count - 1;
+      if (Closed) while (highI > 0 && (pg[highI] == pg[0])) --highI;
+      while (highI > 0 && (pg[highI] == pg[highI - 1])) --highI;
+      if ((Closed && highI < 2) || (!Closed && highI < 1)) return false;
+
+      //create a new edge array ...
+      List<TEdge> edges = new List<TEdge>(highI+1);
+      for (int i = 0; i <= highI; i++) edges.Add(new TEdge());
+          
+      bool IsFlat = true;
+
+      //1. Basic (first) edge initialization ...
+      edges[1].Curr = pg[1];
+      RangeTest(pg[0], ref m_UseFullRange);
+      RangeTest(pg[highI], ref m_UseFullRange);
+      InitEdge(edges[0], edges[1], edges[highI], pg[0]);
+      InitEdge(edges[highI], edges[0], edges[highI - 1], pg[highI]);
+      for (int i = highI - 1; i >= 1; --i)
+      {
+        RangeTest(pg[i], ref m_UseFullRange);
+        InitEdge(edges[i], edges[i + 1], edges[i - 1], pg[i]);
+      }
+      TEdge eStart = edges[0];
+
+      //2. Remove duplicate vertices, and (when closed) collinear edges ...
+      TEdge E = eStart, eLoopStop = eStart;
+      for (;;)
+      {
+        //nb: allows matching start and end points when not Closed ...
+        if (E.Curr == E.Next.Curr && (Closed || E.Next != eStart))
+        {
+          if (E == E.Next) break;
+          if (E == eStart) eStart = E.Next;
+          E = RemoveEdge(E);
+          eLoopStop = E;
+          continue;
+        }
+        if (E.Prev == E.Next) 
+          break; //only two vertices
+        else if (Closed &&
+          SlopesEqual(E.Prev.Curr, E.Curr, E.Next.Curr, m_UseFullRange) && 
+          (!PreserveCollinear ||
+          !Pt2IsBetweenPt1AndPt3(E.Prev.Curr, E.Curr, E.Next.Curr))) 
+        {
+          //Collinear edges are allowed for open paths but in closed paths
+          //the default is to merge adjacent collinear edges into a single edge.
+          //However, if the PreserveCollinear property is enabled, only overlapping
+          //collinear edges (ie spikes) will be removed from closed paths.
+          if (E == eStart) eStart = E.Next;
+          E = RemoveEdge(E);
+          E = E.Prev;
+          eLoopStop = E;
+          continue;
+        }
+        E = E.Next;
+        if ((E == eLoopStop) || (!Closed && E.Next == eStart)) break;
+      }
+
+      if ((!Closed && (E == E.Next)) || (Closed && (E.Prev == E.Next)))
+        return false;
+
+      if (!Closed)
+      {
+        m_HasOpenPaths = true;
+        eStart.Prev.OutIdx = Skip;
+      }
+
+      //3. Do second stage of edge initialization ...
+      E = eStart;
+      do
+      {
+        InitEdge2(E, polyType);
+        E = E.Next;
+        if (IsFlat && E.Curr.Y != eStart.Curr.Y) IsFlat = false;
+      }
+      while (E != eStart);
+
+      //4. Finally, add edge bounds to LocalMinima list ...
+
+      //Totally flat paths must be handled differently when adding them
+      //to LocalMinima list to avoid endless loops etc ...
+      if (IsFlat) 
+      {
+        if (Closed) return false;
+        E.Prev.OutIdx = Skip;
+        LocalMinima locMin = new LocalMinima();
+        locMin.Next = null;
+        locMin.Y = E.Bot.Y;
+        locMin.LeftBound = null;
+        locMin.RightBound = E;
+        locMin.RightBound.Side = EdgeSide.esRight;
+        locMin.RightBound.WindDelta = 0;
+        for ( ; ; )
+        {
+          if (E.Bot.X != E.Prev.Top.X) ReverseHorizontal(E);
+          if (E.Next.OutIdx == Skip) break;
+          E.NextInLML = E.Next;
+          E = E.Next;
+        }
+        InsertLocalMinima(locMin);
+        m_edges.Add(edges);
+        return true;
+      }
+
+      m_edges.Add(edges);
+      bool leftBoundIsForward;
+      TEdge EMin = null;
+
+      //workaround to avoid an endless loop in the while loop below when
+      //open paths have matching start and end points ...
+      if (E.Prev.Bot == E.Prev.Top) E = E.Next;
+
+      for (;;)
+      {
+        E = FindNextLocMin(E);
+        if (E == EMin) break;
+        else if (EMin == null) EMin = E;
+
+        //E and E.Prev now share a local minima (left aligned if horizontal).
+        //Compare their slopes to find which starts which bound ...
+        LocalMinima locMin = new LocalMinima();
+        locMin.Next = null;
+        locMin.Y = E.Bot.Y;
+        if (E.Dx < E.Prev.Dx) 
+        {
+          locMin.LeftBound = E.Prev;
+          locMin.RightBound = E;
+          leftBoundIsForward = false; //Q.nextInLML = Q.prev
+        } else
+        {
+          locMin.LeftBound = E;
+          locMin.RightBound = E.Prev;
+          leftBoundIsForward = true; //Q.nextInLML = Q.next
+        }
+        locMin.LeftBound.Side = EdgeSide.esLeft;
+        locMin.RightBound.Side = EdgeSide.esRight;
+
+        if (!Closed) locMin.LeftBound.WindDelta = 0;
+        else if (locMin.LeftBound.Next == locMin.RightBound)
+          locMin.LeftBound.WindDelta = -1;
+        else locMin.LeftBound.WindDelta = 1;
+        locMin.RightBound.WindDelta = -locMin.LeftBound.WindDelta;
+
+        E = ProcessBound(locMin.LeftBound, leftBoundIsForward);
+        if (E.OutIdx == Skip) E = ProcessBound(E, leftBoundIsForward);
+
+        TEdge E2 = ProcessBound(locMin.RightBound, !leftBoundIsForward);
+        if (E2.OutIdx == Skip) E2 = ProcessBound(E2, !leftBoundIsForward);
+
+        if (locMin.LeftBound.OutIdx == Skip)
+          locMin.LeftBound = null;
+        else if (locMin.RightBound.OutIdx == Skip)
+          locMin.RightBound = null;
+        InsertLocalMinima(locMin);
+        if (!leftBoundIsForward) E = E2;
+      }
+      return true;
+
+    }
+    //------------------------------------------------------------------------------
+
+    public bool AddPaths(Paths ppg, PolyType polyType, bool closed)
+    {
+      bool result = false;
+      for (int i = 0; i < ppg.Count; ++i)
+        if (AddPath(ppg[i], polyType, closed)) result = true;
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal bool Pt2IsBetweenPt1AndPt3(IntPoint pt1, IntPoint pt2, IntPoint pt3)
+    {
+      if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2)) return false;
+      else if (pt1.X != pt3.X) return (pt2.X > pt1.X) == (pt2.X < pt3.X);
+      else return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y);
+    }
+    //------------------------------------------------------------------------------
+
+    TEdge RemoveEdge(TEdge e)
+    {
+      //removes e from double_linked_list (but without removing from memory)
+      e.Prev.Next = e.Next;
+      e.Next.Prev = e.Prev;
+      TEdge result = e.Next;
+      e.Prev = null; //flag as removed (see ClipperBase.Clear)
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    private void SetDx(TEdge e)
+    {
+      e.Delta.X = (e.Top.X - e.Bot.X);
+      e.Delta.Y = (e.Top.Y - e.Bot.Y);
+      if (e.Delta.Y == 0) e.Dx = horizontal;
+      else e.Dx = (double)(e.Delta.X) / (e.Delta.Y);
+    }
+    //---------------------------------------------------------------------------
+
+    private void InsertLocalMinima(LocalMinima newLm)
+    {
+      if( m_MinimaList == null )
+      {
+        m_MinimaList = newLm;
+      }
+      else if( newLm.Y >= m_MinimaList.Y )
+      {
+        newLm.Next = m_MinimaList;
+        m_MinimaList = newLm;
+      } else
+      {
+        LocalMinima tmpLm = m_MinimaList;
+        while( tmpLm.Next != null  && ( newLm.Y < tmpLm.Next.Y ) )
+          tmpLm = tmpLm.Next;
+        newLm.Next = tmpLm.Next;
+        tmpLm.Next = newLm;
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean PopLocalMinima(cInt Y, out LocalMinima current)
+    {
+        current = m_CurrentLM;
+        if (m_CurrentLM != null && m_CurrentLM.Y == Y)
+        {
+            m_CurrentLM = m_CurrentLM.Next;
+            return true;
+        }
+        return false;
+    }
+    //------------------------------------------------------------------------------
+
+    private void ReverseHorizontal(TEdge e)
+    {
+      //swap horizontal edges' top and bottom x's so they follow the natural
+      //progression of the bounds - ie so their xbots will align with the
+      //adjoining lower edge. [Helpful in the ProcessHorizontal() method.]
+      Swap(ref e.Top.X, ref e.Bot.X);
+#if use_xyz
+      Swap(ref e.Top.Z, ref e.Bot.Z);
+#endif
+    }
+    //------------------------------------------------------------------------------
+
+    internal virtual void Reset()
+    {
+      m_CurrentLM = m_MinimaList;
+      if (m_CurrentLM == null) return; //ie nothing to process
+
+      //reset all edges ...
+      m_Scanbeam = null;
+      LocalMinima lm = m_MinimaList;
+      while (lm != null)
+      {
+        InsertScanbeam(lm.Y);
+        TEdge e = lm.LeftBound;
+        if (e != null)
+        {
+          e.Curr = e.Bot;
+          e.OutIdx = Unassigned;
+        }
+        e = lm.RightBound;
+        if (e != null)
+        {
+          e.Curr = e.Bot;
+          e.OutIdx = Unassigned;
+        }
+        lm = lm.Next;
+      }
+      m_ActiveEdges = null;
+    }
+    //------------------------------------------------------------------------------
+
+    public static IntRect GetBounds(Paths paths)
+    {
+      int i = 0, cnt = paths.Count;
+      while (i < cnt && paths[i].Count == 0) i++;
+      if (i == cnt) return new IntRect(0,0,0,0);
+      IntRect result = new IntRect();
+      result.left = paths[i][0].X;
+      result.right = result.left;
+      result.top = paths[i][0].Y;
+      result.bottom = result.top;
+      for (; i < cnt; i++)
+        for (int j = 0; j < paths[i].Count; j++)
+        {
+          if (paths[i][j].X < result.left) result.left = paths[i][j].X;
+          else if (paths[i][j].X > result.right) result.right = paths[i][j].X;
+          if (paths[i][j].Y < result.top) result.top = paths[i][j].Y;
+          else if (paths[i][j].Y > result.bottom) result.bottom = paths[i][j].Y;
+        }
+      return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void InsertScanbeam(cInt Y)
+    {
+        //single-linked list: sorted descending, ignoring dups.
+        if (m_Scanbeam == null)
+        {
+            m_Scanbeam = new Scanbeam();
+            m_Scanbeam.Next = null;
+            m_Scanbeam.Y = Y;
+        }
+        else if (Y > m_Scanbeam.Y)
+        {
+            Scanbeam newSb = new Scanbeam();
+            newSb.Y = Y;
+            newSb.Next = m_Scanbeam;
+            m_Scanbeam = newSb;
+        }
+        else
+        {
+            Scanbeam sb2 = m_Scanbeam;
+            while (sb2.Next != null && (Y <= sb2.Next.Y)) sb2 = sb2.Next;
+            if (Y == sb2.Y) return; //ie ignores duplicates
+            Scanbeam newSb = new Scanbeam();
+            newSb.Y = Y;
+            newSb.Next = sb2.Next;
+            sb2.Next = newSb;
+        }
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean PopScanbeam(out cInt Y)
+    {
+        if (m_Scanbeam == null)
+        {
+            Y = 0;
+            return false;
+        }
+        Y = m_Scanbeam.Y;
+        m_Scanbeam = m_Scanbeam.Next;
+        return true;
+    }
+    //------------------------------------------------------------------------------
+
+    internal Boolean LocalMinimaPending()
+    {
+        return (m_CurrentLM != null);
+    }
+    //------------------------------------------------------------------------------
+
+    internal OutRec CreateOutRec()
+    {
+        OutRec result = new OutRec();
+        result.Idx = Unassigned;
+        result.IsHole = false;
+        result.IsOpen = false;
+        result.FirstLeft = null;
+        result.Pts = null;
+        result.BottomPt = null;
+        result.PolyNode = null;
+        m_PolyOuts.Add(result);
+        result.Idx = m_PolyOuts.Count - 1;
+        return result;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DisposeOutRec(int index)
+    {
+        OutRec outRec = m_PolyOuts[index];
+        outRec.Pts = null;
+        outRec = null;
+        m_PolyOuts[index] = null;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void UpdateEdgeIntoAEL(ref TEdge e)
+    {
+        if (e.NextInLML == null)
+            throw new ClipperException("UpdateEdgeIntoAEL: invalid call");
+        TEdge AelPrev = e.PrevInAEL;
+        TEdge AelNext = e.NextInAEL;
+        e.NextInLML.OutIdx = e.OutIdx;
+        if (AelPrev != null)
+            AelPrev.NextInAEL = e.NextInLML;
+        else m_ActiveEdges = e.NextInLML;
+        if (AelNext != null)
+            AelNext.PrevInAEL = e.NextInLML;
+        e.NextInLML.Side = e.Side;
+        e.NextInLML.WindDelta = e.WindDelta;
+        e.NextInLML.WindCnt = e.WindCnt;
+        e.NextInLML.WindCnt2 = e.WindCnt2;
+        e = e.NextInLML;
+        e.Curr = e.Bot;
+        e.PrevInAEL = AelPrev;
+        e.NextInAEL = AelNext;
+        if (!IsHorizontal(e)) InsertScanbeam(e.Top.Y);
+    }
+    //------------------------------------------------------------------------------
+
+    internal void SwapPositionsInAEL(TEdge edge1, TEdge edge2)
+    {
+        //check that one or other edge hasn't already been removed from AEL ...
+        if (edge1.NextInAEL == edge1.PrevInAEL ||
+          edge2.NextInAEL == edge2.PrevInAEL) return;
+
+        if (edge1.NextInAEL == edge2)
+        {
+            TEdge next = edge2.NextInAEL;
+            if (next != null)
+                next.PrevInAEL = edge1;
+            TEdge prev = edge1.PrevInAEL;
+            if (prev != null)
+                prev.NextInAEL = edge2;
+            edge2.PrevInAEL = prev;
+            edge2.NextInAEL = edge1;
+            edge1.PrevInAEL = edge2;
+            edge1.NextInAEL = next;
+        }
+        else if (edge2.NextInAEL == edge1)
+        {
+            TEdge next = edge1.NextInAEL;
+            if (next != null)
+                next.PrevInAEL = edge2;
+            TEdge prev = edge2.PrevInAEL;
+            if (prev != null)
+                prev.NextInAEL = edge1;
+            edge1.PrevInAEL = prev;
+            edge1.NextInAEL = edge2;
+            edge2.PrevInAEL = edge1;
+            edge2.NextInAEL = next;
+        }
+        else
+        {
+            TEdge next = edge1.NextInAEL;
+            TEdge prev = edge1.PrevInAEL;
+            edge1.NextInAEL = edge2.NextInAEL;
+            if (edge1.NextInAEL != null)
+                edge1.NextInAEL.PrevInAEL = edge1;
+            edge1.PrevInAEL = edge2.PrevInAEL;
+            if (edge1.PrevInAEL != null)
+                edge1.PrevInAEL.NextInAEL = edge1;
+            edge2.NextInAEL = next;
+            if (edge2.NextInAEL != null)
+                edge2.NextInAEL.PrevInAEL = edge2;
+            edge2.PrevInAEL = prev;
+            if (edge2.PrevInAEL != null)
+                edge2.PrevInAEL.NextInAEL = edge2;
+        }
+
+        if (edge1.PrevInAEL == null)
+            m_ActiveEdges = edge1;
+        else if (edge2.PrevInAEL == null)
+            m_ActiveEdges = edge2;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DeleteFromAEL(TEdge e)
+    {
+        TEdge AelPrev = e.PrevInAEL;
+        TEdge AelNext = e.NextInAEL;
+        if (AelPrev == null && AelNext == null && (e != m_ActiveEdges))
+            return; //already deleted
+        if (AelPrev != null)
+            AelPrev.NextInAEL = AelNext;
+        else m_ActiveEdges = AelNext;
+        if (AelNext != null)
+            AelNext.PrevInAEL = AelPrev;
+        e.NextInAEL = null;
+        e.PrevInAEL = null;
+    }
+    //------------------------------------------------------------------------------
+
+  } //end ClipperBase
+
+  internal class Clipper : ClipperBase
+  {
+      //InitOptions that can be passed to the constructor ...
+      public const int ioReverseSolution = 1;
+      public const int ioStrictlySimple = 2;
+      public const int ioPreserveCollinear = 4;
+
+      private ClipType m_ClipType;
+      private Maxima m_Maxima;
+      private TEdge m_SortedEdges;
+      private List<IntersectNode> m_IntersectList;
+      IComparer<IntersectNode> m_IntersectNodeComparer;
+      private bool m_ExecuteLocked;
+      private PolyFillType m_ClipFillType;
+      private PolyFillType m_SubjFillType;
+      private List<Join> m_Joins;
+      private List<Join> m_GhostJoins;
+      private bool m_UsingPolyTree;
+#if use_xyz
+      public delegate void ZFillCallback(IntPoint bot1, IntPoint top1, 
+        IntPoint bot2, IntPoint top2, ref IntPoint pt);
+      public ZFillCallback ZFillFunction { get; set; }
+#endif
+      public Clipper(int InitOptions = 0): base() //constructor
+      {
+          m_Scanbeam = null;
+          m_Maxima = null;
+          m_ActiveEdges = null;
+          m_SortedEdges = null;
+          m_IntersectList = new List<IntersectNode>();
+          m_IntersectNodeComparer = new MyIntersectNodeSort();
+          m_ExecuteLocked = false;
+          m_UsingPolyTree = false;
+          m_PolyOuts = new List<OutRec>();
+          m_Joins = new List<Join>();
+          m_GhostJoins = new List<Join>();
+          ReverseSolution = (ioReverseSolution & InitOptions) != 0;
+          StrictlySimple = (ioStrictlySimple & InitOptions) != 0;
+          PreserveCollinear = (ioPreserveCollinear & InitOptions) != 0;
+#if use_xyz
+          ZFillFunction = null;
+#endif
+      }
+      //------------------------------------------------------------------------------
+
+      private void InsertMaxima(cInt X)
+      {
+          //double-linked list: sorted ascending, ignoring dups.
+          Maxima newMax = new Maxima();
+          newMax.X = X;
+          if (m_Maxima == null)
+          {
+              m_Maxima = newMax;
+              m_Maxima.Next = null;
+              m_Maxima.Prev = null;
+          }
+          else if (X < m_Maxima.X)
+          {
+              newMax.Next = m_Maxima;
+              newMax.Prev = null;
+              m_Maxima = newMax;
+          }
+          else
+          {
+              Maxima m = m_Maxima;
+              while (m.Next != null && (X >= m.Next.X)) m = m.Next;
+              if (X == m.X) return; //ie ignores duplicates (& CG to clean up newMax)
+              //insert newMax between m and m.Next ...
+              newMax.Next = m.Next;
+              newMax.Prev = m;
+              if (m.Next != null) m.Next.Prev = newMax;
+              m.Next = newMax;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      public bool ReverseSolution
+      {
+        get;
+        set;
+      }
+      //------------------------------------------------------------------------------
+
+      public bool StrictlySimple
+      {
+        get; 
+        set;
+      }
+      //------------------------------------------------------------------------------
+       
+      public bool Execute(ClipType clipType, Paths solution, 
+          PolyFillType FillType = PolyFillType.pftEvenOdd)
+      {
+          return Execute(clipType, solution, FillType, FillType);
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, PolyTree polytree,
+          PolyFillType FillType = PolyFillType.pftEvenOdd)
+      {
+          return Execute(clipType, polytree, FillType, FillType);
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, Paths solution,
+          PolyFillType subjFillType, PolyFillType clipFillType)
+      {
+          if (m_ExecuteLocked) return false;
+          if (m_HasOpenPaths) throw 
+            new ClipperException("Error: PolyTree struct is needed for open path clipping.");
+
+          m_ExecuteLocked = true;
+          solution.Clear();
+          m_SubjFillType = subjFillType;
+          m_ClipFillType = clipFillType;
+          m_ClipType = clipType;
+          m_UsingPolyTree = false;
+          bool succeeded;
+          try
+          {
+            succeeded = ExecuteInternal();
+            //build the return polygons ...
+            if (succeeded) BuildResult(solution);
+          }
+          finally
+          {
+            DisposeAllPolyPts();
+            m_ExecuteLocked = false;
+          }
+          return succeeded;
+      }
+      //------------------------------------------------------------------------------
+
+      public bool Execute(ClipType clipType, PolyTree polytree,
+          PolyFillType subjFillType, PolyFillType clipFillType)
+      {
+          if (m_ExecuteLocked) return false;
+          m_ExecuteLocked = true;
+          m_SubjFillType = subjFillType;
+          m_ClipFillType = clipFillType;
+          m_ClipType = clipType;
+          m_UsingPolyTree = true;
+          bool succeeded;
+          try
+          {
+            succeeded = ExecuteInternal();
+            //build the return polygons ...
+            if (succeeded) BuildResult2(polytree);
+          }
+          finally
+          {
+            DisposeAllPolyPts();
+            m_ExecuteLocked = false;
+          }
+          return succeeded;
+      }
+      //------------------------------------------------------------------------------
+
+      internal void FixHoleLinkage(OutRec outRec)
+      {
+        //skip if an outermost polygon or
+        //already already points to the correct FirstLeft ...
+        if (outRec.FirstLeft == null ||
+              (outRec.IsHole != outRec.FirstLeft.IsHole &&
+              outRec.FirstLeft.Pts != null)) return;
+
+        OutRec orfl = outRec.FirstLeft;
+        while (orfl != null && ((orfl.IsHole == outRec.IsHole) || orfl.Pts == null))
+          orfl = orfl.FirstLeft;
+        outRec.FirstLeft = orfl;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool ExecuteInternal()
+      {
+        try
+        {
+          Reset();
+          m_SortedEdges = null;
+          m_Maxima = null;
+
+          cInt botY, topY;
+          if (!PopScanbeam(out botY)) return false;
+          InsertLocalMinimaIntoAEL(botY);
+          while (PopScanbeam(out topY) || LocalMinimaPending())
+          {
+            ProcessHorizontals();
+            m_GhostJoins.Clear();
+            if (!ProcessIntersections(topY)) return false;
+            ProcessEdgesAtTopOfScanbeam(topY);
+            botY = topY;
+            InsertLocalMinimaIntoAEL(botY);
+          } 
+
+          //fix orientations ...
+          foreach (OutRec outRec in m_PolyOuts)
+          {
+            if (outRec.Pts == null || outRec.IsOpen) continue;
+            if ((outRec.IsHole ^ ReverseSolution) == (Area(outRec) > 0))
+              ReversePolyPtLinks(outRec.Pts);
+          }
+
+          JoinCommonEdges();
+
+          foreach (OutRec outRec in m_PolyOuts)
+          {
+            if (outRec.Pts == null) 
+                continue;
+            else if (outRec.IsOpen)
+                FixupOutPolyline(outRec);
+            else
+                FixupOutPolygon(outRec);
+          }
+
+          if (StrictlySimple) DoSimplePolygons();
+          return true;
+        }
+        //catch { return false; }
+        finally 
+        {
+          m_Joins.Clear();
+          m_GhostJoins.Clear();          
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DisposeAllPolyPts(){
+        for (int i = 0; i < m_PolyOuts.Count; ++i) DisposeOutRec(i);
+        m_PolyOuts.Clear();
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddJoin(OutPt Op1, OutPt Op2, IntPoint OffPt)
+      {
+        Join j = new Join();
+        j.OutPt1 = Op1;
+        j.OutPt2 = Op2;
+        j.OffPt = OffPt;
+        m_Joins.Add(j);
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddGhostJoin(OutPt Op, IntPoint OffPt)
+      {
+        Join j = new Join();
+        j.OutPt1 = Op;
+        j.OffPt = OffPt;
+        m_GhostJoins.Add(j);
+      }
+      //------------------------------------------------------------------------------
+
+#if use_xyz
+      internal void SetZ(ref IntPoint pt, TEdge e1, TEdge e2)
+      {
+        if (pt.Z != 0 || ZFillFunction == null) return;
+        else if (pt == e1.Bot) pt.Z = e1.Bot.Z;
+        else if (pt == e1.Top) pt.Z = e1.Top.Z;
+        else if (pt == e2.Bot) pt.Z = e2.Bot.Z;
+        else if (pt == e2.Top) pt.Z = e2.Top.Z;
+        else ZFillFunction(e1.Bot, e1.Top, e2.Bot, e2.Top, ref pt);
+      }
+      //------------------------------------------------------------------------------
+#endif
+
+      private void InsertLocalMinimaIntoAEL(cInt botY)
+      {
+        LocalMinima lm;
+        while (PopLocalMinima(botY, out lm))
+        {
+          TEdge lb = lm.LeftBound;
+          TEdge rb = lm.RightBound;
+
+          OutPt Op1 = null;
+          if (lb == null)
+          {
+            InsertEdgeIntoAEL(rb, null);
+            SetWindingCount(rb);
+            if (IsContributing(rb))
+              Op1 = AddOutPt(rb, rb.Bot);
+          }
+          else if (rb == null)
+          {
+            InsertEdgeIntoAEL(lb, null);
+            SetWindingCount(lb);
+            if (IsContributing(lb))
+              Op1 = AddOutPt(lb, lb.Bot);
+            InsertScanbeam(lb.Top.Y);
+          }
+          else
+          {
+            InsertEdgeIntoAEL(lb, null);
+            InsertEdgeIntoAEL(rb, lb);
+            SetWindingCount(lb);
+            rb.WindCnt = lb.WindCnt;
+            rb.WindCnt2 = lb.WindCnt2;
+            if (IsContributing(lb))
+              Op1 = AddLocalMinPoly(lb, rb, lb.Bot);
+            InsertScanbeam(lb.Top.Y);
+          }
+
+          if (rb != null)
+          {
+            if (IsHorizontal(rb))
+            {
+              if (rb.NextInLML != null)
+                InsertScanbeam(rb.NextInLML.Top.Y);
+              AddEdgeToSEL(rb);
+            }
+            else
+              InsertScanbeam(rb.Top.Y);
+          }
+
+        if (lb == null || rb == null) continue;
+
+          //if output polygons share an Edge with a horizontal rb, they'll need joining later ...
+          if (Op1 != null && IsHorizontal(rb) && 
+            m_GhostJoins.Count > 0 && rb.WindDelta != 0)
+          {
+            for (int i = 0; i < m_GhostJoins.Count; i++)
+            {
+              //if the horizontal Rb and a 'ghost' horizontal overlap, then convert
+              //the 'ghost' join to a real join ready for later ...
+              Join j = m_GhostJoins[i];
+              if (HorzSegmentsOverlap(j.OutPt1.Pt.X, j.OffPt.X, rb.Bot.X, rb.Top.X))
+                AddJoin(j.OutPt1, Op1, j.OffPt);
+            }
+          }
+
+          if (lb.OutIdx >= 0 && lb.PrevInAEL != null &&
+            lb.PrevInAEL.Curr.X == lb.Bot.X &&
+            lb.PrevInAEL.OutIdx >= 0 &&
+            SlopesEqual(lb.PrevInAEL.Curr, lb.PrevInAEL.Top, lb.Curr, lb.Top, m_UseFullRange) &&
+            lb.WindDelta != 0 && lb.PrevInAEL.WindDelta != 0)
+          {
+            OutPt Op2 = AddOutPt(lb.PrevInAEL, lb.Bot);
+            AddJoin(Op1, Op2, lb.Top);
+          }
+
+          if( lb.NextInAEL != rb )
+          {
+
+            if (rb.OutIdx >= 0 && rb.PrevInAEL.OutIdx >= 0 &&
+              SlopesEqual(rb.PrevInAEL.Curr, rb.PrevInAEL.Top, rb.Curr, rb.Top, m_UseFullRange) &&
+              rb.WindDelta != 0 && rb.PrevInAEL.WindDelta != 0)
+            {
+              OutPt Op2 = AddOutPt(rb.PrevInAEL, rb.Bot);
+              AddJoin(Op1, Op2, rb.Top);
+            }
+
+            TEdge e = lb.NextInAEL;
+            if (e != null)
+              while (e != rb)
+              {
+                //nb: For calculating winding counts etc, IntersectEdges() assumes
+                //that param1 will be to the right of param2 ABOVE the intersection ...
+                IntersectEdges(rb, e, lb.Curr); //order important here
+                e = e.NextInAEL;
+              }
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void InsertEdgeIntoAEL(TEdge edge, TEdge startEdge)
+      {
+        if (m_ActiveEdges == null)
+        {
+          edge.PrevInAEL = null;
+          edge.NextInAEL = null;
+          m_ActiveEdges = edge;
+        }
+        else if (startEdge == null && E2InsertsBeforeE1(m_ActiveEdges, edge))
+        {
+          edge.PrevInAEL = null;
+          edge.NextInAEL = m_ActiveEdges;
+          m_ActiveEdges.PrevInAEL = edge;
+          m_ActiveEdges = edge;
+        }
+        else
+        {
+          if (startEdge == null) startEdge = m_ActiveEdges;
+          while (startEdge.NextInAEL != null &&
+            !E2InsertsBeforeE1(startEdge.NextInAEL, edge))
+            startEdge = startEdge.NextInAEL;
+          edge.NextInAEL = startEdge.NextInAEL;
+          if (startEdge.NextInAEL != null) startEdge.NextInAEL.PrevInAEL = edge;
+          edge.PrevInAEL = startEdge;
+          startEdge.NextInAEL = edge;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private bool E2InsertsBeforeE1(TEdge e1, TEdge e2)
+      {
+          if (e2.Curr.X == e1.Curr.X)
+          {
+              if (e2.Top.Y > e1.Top.Y)
+                  return e2.Top.X < TopX(e1, e2.Top.Y);
+              else return e1.Top.X > TopX(e2, e1.Top.Y);
+          }
+          else return e2.Curr.X < e1.Curr.X;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsEvenOddFillType(TEdge edge) 
+      {
+        if (edge.PolyTyp == PolyType.ptSubject)
+            return m_SubjFillType == PolyFillType.pftEvenOdd; 
+        else
+            return m_ClipFillType == PolyFillType.pftEvenOdd;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsEvenOddAltFillType(TEdge edge) 
+      {
+        if (edge.PolyTyp == PolyType.ptSubject)
+            return m_ClipFillType == PolyFillType.pftEvenOdd; 
+        else
+            return m_SubjFillType == PolyFillType.pftEvenOdd;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsContributing(TEdge edge)
+      {
+          PolyFillType pft, pft2;
+          if (edge.PolyTyp == PolyType.ptSubject)
+          {
+              pft = m_SubjFillType;
+              pft2 = m_ClipFillType;
+          }
+          else
+          {
+              pft = m_ClipFillType;
+              pft2 = m_SubjFillType;
+          }
+
+          switch (pft)
+          {
+              case PolyFillType.pftEvenOdd:
+                  //return false if a subj line has been flagged as inside a subj polygon
+                  if (edge.WindDelta == 0 && edge.WindCnt != 1) return false;
+                  break;
+              case PolyFillType.pftNonZero:
+                  if (Math.Abs(edge.WindCnt) != 1) return false;
+                  break;
+              case PolyFillType.pftPositive:
+                  if (edge.WindCnt != 1) return false;
+                  break;
+              default: //PolyFillType.pftNegative
+                  if (edge.WindCnt != -1) return false; 
+                  break;
+          }
+
+          switch (m_ClipType)
+          {
+            case ClipType.ctIntersection:
+                switch (pft2)
+                {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                        return (edge.WindCnt2 != 0);
+                    case PolyFillType.pftPositive:
+                        return (edge.WindCnt2 > 0);
+                    default:
+                        return (edge.WindCnt2 < 0);
+                }
+            case ClipType.ctUnion:
+                switch (pft2)
+                {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                        return (edge.WindCnt2 == 0);
+                    case PolyFillType.pftPositive:
+                        return (edge.WindCnt2 <= 0);
+                    default:
+                        return (edge.WindCnt2 >= 0);
+                }
+            case ClipType.ctDifference:
+                if (edge.PolyTyp == PolyType.ptSubject)
+                    switch (pft2)
+                    {
+                        case PolyFillType.pftEvenOdd:
+                        case PolyFillType.pftNonZero:
+                            return (edge.WindCnt2 == 0);
+                        case PolyFillType.pftPositive:
+                            return (edge.WindCnt2 <= 0);
+                        default:
+                            return (edge.WindCnt2 >= 0);
+                    }
+                else
+                    switch (pft2)
+                    {
+                        case PolyFillType.pftEvenOdd:
+                        case PolyFillType.pftNonZero:
+                            return (edge.WindCnt2 != 0);
+                        case PolyFillType.pftPositive:
+                            return (edge.WindCnt2 > 0);
+                        default:
+                            return (edge.WindCnt2 < 0);
+                    }
+            case ClipType.ctXor:
+                if (edge.WindDelta == 0) //XOr always contributing unless open
+                  switch (pft2)
+                  {
+                    case PolyFillType.pftEvenOdd:
+                    case PolyFillType.pftNonZero:
+                      return (edge.WindCnt2 == 0);
+                    case PolyFillType.pftPositive:
+                      return (edge.WindCnt2 <= 0);
+                    default:
+                      return (edge.WindCnt2 >= 0);
+                  }
+                else
+                  return true;
+          }
+          return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void SetWindingCount(TEdge edge)
+      {
+        TEdge e = edge.PrevInAEL;
+        //find the edge of the same polytype that immediately preceeds 'edge' in AEL
+        while (e != null && ((e.PolyTyp != edge.PolyTyp) || (e.WindDelta == 0))) e = e.PrevInAEL;
+        if (e == null)
+        {
+          PolyFillType pft;
+          pft = (edge.PolyTyp == PolyType.ptSubject ? m_SubjFillType : m_ClipFillType);
+          if (edge.WindDelta == 0) edge.WindCnt = (pft == PolyFillType.pftNegative ? -1 : 1);
+          else edge.WindCnt = edge.WindDelta;
+          edge.WindCnt2 = 0;
+          e = m_ActiveEdges; //ie get ready to calc WindCnt2
+        }
+        else if (edge.WindDelta == 0 && m_ClipType != ClipType.ctUnion)
+        {
+          edge.WindCnt = 1;
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+        else if (IsEvenOddFillType(edge))
+        {
+          //EvenOdd filling ...
+          if (edge.WindDelta == 0)
+          {
+            //are we inside a subj polygon ...
+            bool Inside = true;
+            TEdge e2 = e.PrevInAEL;
+            while (e2 != null)
+            {
+              if (e2.PolyTyp == e.PolyTyp && e2.WindDelta != 0)
+                Inside = !Inside;
+              e2 = e2.PrevInAEL;
+            }
+            edge.WindCnt = (Inside ? 0 : 1);
+          }
+          else
+          {
+            edge.WindCnt = edge.WindDelta;
+          }
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+        else
+        {
+          //nonZero, Positive or Negative filling ...
+          if (e.WindCnt * e.WindDelta < 0)
+          {
+            //prev edge is 'decreasing' WindCount (WC) toward zero
+            //so we're outside the previous polygon ...
+            if (Math.Abs(e.WindCnt) > 1)
+            {
+              //outside prev poly but still inside another.
+              //when reversing direction of prev poly use the same WC 
+              if (e.WindDelta * edge.WindDelta < 0) edge.WindCnt = e.WindCnt;
+              //otherwise continue to 'decrease' WC ...
+              else edge.WindCnt = e.WindCnt + edge.WindDelta;
+            }
+            else
+              //now outside all polys of same polytype so set own WC ...
+              edge.WindCnt = (edge.WindDelta == 0 ? 1 : edge.WindDelta);
+          }
+          else
+          {
+            //prev edge is 'increasing' WindCount (WC) away from zero
+            //so we're inside the previous polygon ...
+            if (edge.WindDelta == 0)
+              edge.WindCnt = (e.WindCnt < 0 ? e.WindCnt - 1 : e.WindCnt + 1);
+            //if wind direction is reversing prev then use same WC
+            else if (e.WindDelta * edge.WindDelta < 0)
+              edge.WindCnt = e.WindCnt;
+            //otherwise add to WC ...
+            else edge.WindCnt = e.WindCnt + edge.WindDelta;
+          }
+          edge.WindCnt2 = e.WindCnt2;
+          e = e.NextInAEL; //ie get ready to calc WindCnt2
+        }
+
+        //update WindCnt2 ...
+        if (IsEvenOddAltFillType(edge))
+        {
+          //EvenOdd filling ...
+          while (e != edge)
+          {
+            if (e.WindDelta != 0)
+              edge.WindCnt2 = (edge.WindCnt2 == 0 ? 1 : 0);
+            e = e.NextInAEL;
+          }
+        }
+        else
+        {
+          //nonZero, Positive or Negative filling ...
+          while (e != edge)
+          {
+            edge.WindCnt2 += e.WindDelta;
+            e = e.NextInAEL;
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void AddEdgeToSEL(TEdge edge)
+      {
+        //SEL pointers in PEdge are use to build transient lists of horizontal edges.
+        //However, since we don't need to worry about processing order, all additions
+        //are made to the front of the list ...
+        if (m_SortedEdges == null)
+        {
+            m_SortedEdges = edge;
+            edge.PrevInSEL = null;
+            edge.NextInSEL = null;
+        }
+        else
+        {
+            edge.NextInSEL = m_SortedEdges;
+            edge.PrevInSEL = null;
+            m_SortedEdges.PrevInSEL = edge;
+            m_SortedEdges = edge;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      internal Boolean PopEdgeFromSEL(out TEdge e)
+      {
+        //Pop edge from front of SEL (ie SEL is a FILO list)
+        e = m_SortedEdges;
+        if (e == null) return false;
+        TEdge oldE = e;
+        m_SortedEdges = e.NextInSEL;
+        if (m_SortedEdges != null) m_SortedEdges.PrevInSEL = null;
+        oldE.NextInSEL = null;
+        oldE.PrevInSEL = null;
+        return true;
+      }
+      //------------------------------------------------------------------------------
+     
+      private void CopyAELToSEL()
+      {
+          TEdge e = m_ActiveEdges;
+          m_SortedEdges = e;
+          while (e != null)
+          {
+              e.PrevInSEL = e.PrevInAEL;
+              e.NextInSEL = e.NextInAEL;
+              e = e.NextInAEL;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void SwapPositionsInSEL(TEdge edge1, TEdge edge2)
+      {
+          if (edge1.NextInSEL == null && edge1.PrevInSEL == null)
+              return;
+          if (edge2.NextInSEL == null && edge2.PrevInSEL == null)
+              return;
+
+          if (edge1.NextInSEL == edge2)
+          {
+              TEdge next = edge2.NextInSEL;
+              if (next != null)
+                  next.PrevInSEL = edge1;
+              TEdge prev = edge1.PrevInSEL;
+              if (prev != null)
+                  prev.NextInSEL = edge2;
+              edge2.PrevInSEL = prev;
+              edge2.NextInSEL = edge1;
+              edge1.PrevInSEL = edge2;
+              edge1.NextInSEL = next;
+          }
+          else if (edge2.NextInSEL == edge1)
+          {
+              TEdge next = edge1.NextInSEL;
+              if (next != null)
+                  next.PrevInSEL = edge2;
+              TEdge prev = edge2.PrevInSEL;
+              if (prev != null)
+                  prev.NextInSEL = edge1;
+              edge1.PrevInSEL = prev;
+              edge1.NextInSEL = edge2;
+              edge2.PrevInSEL = edge1;
+              edge2.NextInSEL = next;
+          }
+          else
+          {
+              TEdge next = edge1.NextInSEL;
+              TEdge prev = edge1.PrevInSEL;
+              edge1.NextInSEL = edge2.NextInSEL;
+              if (edge1.NextInSEL != null)
+                  edge1.NextInSEL.PrevInSEL = edge1;
+              edge1.PrevInSEL = edge2.PrevInSEL;
+              if (edge1.PrevInSEL != null)
+                  edge1.PrevInSEL.NextInSEL = edge1;
+              edge2.NextInSEL = next;
+              if (edge2.NextInSEL != null)
+                  edge2.NextInSEL.PrevInSEL = edge2;
+              edge2.PrevInSEL = prev;
+              if (edge2.PrevInSEL != null)
+                  edge2.PrevInSEL.NextInSEL = edge2;
+          }
+
+          if (edge1.PrevInSEL == null)
+              m_SortedEdges = edge1;
+          else if (edge2.PrevInSEL == null)
+              m_SortedEdges = edge2;
+      }
+      //------------------------------------------------------------------------------
+
+
+      private void AddLocalMaxPoly(TEdge e1, TEdge e2, IntPoint pt)
+      {
+          AddOutPt(e1, pt);
+          if (e2.WindDelta == 0) AddOutPt(e2, pt);
+          if (e1.OutIdx == e2.OutIdx)
+          {
+              e1.OutIdx = Unassigned;
+              e2.OutIdx = Unassigned;
+          }
+          else if (e1.OutIdx < e2.OutIdx) 
+              AppendPolygon(e1, e2);
+          else 
+              AppendPolygon(e2, e1);
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt AddLocalMinPoly(TEdge e1, TEdge e2, IntPoint pt)
+      {
+        OutPt result;
+        TEdge e, prevE;
+        if (IsHorizontal(e2) || (e1.Dx > e2.Dx))
+        {
+          result = AddOutPt(e1, pt);
+          e2.OutIdx = e1.OutIdx;
+          e1.Side = EdgeSide.esLeft;
+          e2.Side = EdgeSide.esRight;
+          e = e1;
+          if (e.PrevInAEL == e2)
+            prevE = e2.PrevInAEL; 
+          else
+            prevE = e.PrevInAEL;
+        }
+        else
+        {
+          result = AddOutPt(e2, pt);
+          e1.OutIdx = e2.OutIdx;
+          e1.Side = EdgeSide.esRight;
+          e2.Side = EdgeSide.esLeft;
+          e = e2;
+          if (e.PrevInAEL == e1)
+              prevE = e1.PrevInAEL;
+          else
+              prevE = e.PrevInAEL;
+        }
+
+        if (prevE != null && prevE.OutIdx >= 0 && prevE.Top.Y < pt.Y && e.Top.Y < pt.Y)
+        {
+          cInt xPrev = TopX(prevE, pt.Y);
+          cInt xE = TopX(e, pt.Y);
+          if ((xPrev == xE) && (e.WindDelta != 0) && (prevE.WindDelta != 0) &&
+            SlopesEqual(new IntPoint(xPrev, pt.Y), prevE.Top, new IntPoint(xE, pt.Y), e.Top, m_UseFullRange))
+          {
+            OutPt outPt = AddOutPt(prevE, pt);
+            AddJoin(result, outPt, e.Top);
+          }
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt AddOutPt(TEdge e, IntPoint pt)
+      {
+          if (e.OutIdx < 0)
+          {
+              OutRec outRec = CreateOutRec();
+              outRec.IsOpen = (e.WindDelta == 0);
+              OutPt newOp = new OutPt();
+              outRec.Pts = newOp;
+              newOp.Idx = outRec.Idx;
+              newOp.Pt = pt;
+              newOp.Next = newOp;
+              newOp.Prev = newOp;
+              if (!outRec.IsOpen)
+                  SetHoleState(e, outRec);
+              e.OutIdx = outRec.Idx; //nb: do this after SetZ !
+              return newOp;
+          }
+          else
+          {
+              OutRec outRec = m_PolyOuts[e.OutIdx];
+              //OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most'
+              OutPt op = outRec.Pts;
+              bool ToFront = (e.Side == EdgeSide.esLeft);
+              if (ToFront && pt == op.Pt) return op;
+              else if (!ToFront && pt == op.Prev.Pt) return op.Prev;
+
+              OutPt newOp = new OutPt();
+              newOp.Idx = outRec.Idx;
+              newOp.Pt = pt;
+              newOp.Next = op;
+              newOp.Prev = op.Prev;
+              newOp.Prev.Next = newOp;
+              op.Prev = newOp;
+              if (ToFront) outRec.Pts = newOp;
+              return newOp;
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt GetLastOutPt(TEdge e)
+      {
+        OutRec outRec = m_PolyOuts[e.OutIdx];
+        if (e.Side == EdgeSide.esLeft) 
+            return outRec.Pts;
+        else
+            return outRec.Pts.Prev;
+      }
+      //------------------------------------------------------------------------------
+
+      internal void SwapPoints(ref IntPoint pt1, ref IntPoint pt2)
+      {
+          IntPoint tmp = new IntPoint(pt1);
+          pt1 = pt2;
+          pt2 = tmp;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool HorzSegmentsOverlap(cInt seg1a, cInt seg1b, cInt seg2a, cInt seg2b)
+      {
+        if (seg1a > seg1b) Swap(ref seg1a, ref seg1b);
+        if (seg2a > seg2b) Swap(ref seg2a, ref seg2b);
+        return (seg1a < seg2b) && (seg2a < seg1b);
+      }
+      //------------------------------------------------------------------------------
+  
+      private void SetHoleState(TEdge e, OutRec outRec)
+      {
+        TEdge e2 = e.PrevInAEL;
+        TEdge eTmp = null;  
+        while (e2 != null)
+          {
+            if (e2.OutIdx >= 0 && e2.WindDelta != 0) 
+            {
+              if (eTmp == null)
+                eTmp = e2;
+              else if (eTmp.OutIdx == e2.OutIdx)
+                eTmp = null; //paired               
+            }
+            e2 = e2.PrevInAEL;
+          }
+
+        if (eTmp == null)
+        {
+          outRec.FirstLeft = null;
+          outRec.IsHole = false;
+        }
+        else
+        {
+          outRec.FirstLeft = m_PolyOuts[eTmp.OutIdx];
+          outRec.IsHole = !outRec.FirstLeft.IsHole;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private double GetDx(IntPoint pt1, IntPoint pt2)
+      {
+          if (pt1.Y == pt2.Y) return horizontal;
+          else return (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y);
+      }
+      //---------------------------------------------------------------------------
+
+      private bool FirstIsBottomPt(OutPt btmPt1, OutPt btmPt2)
+      {
+        OutPt p = btmPt1.Prev;
+        while ((p.Pt == btmPt1.Pt) && (p != btmPt1)) p = p.Prev;
+        double dx1p = Math.Abs(GetDx(btmPt1.Pt, p.Pt));
+        p = btmPt1.Next;
+        while ((p.Pt == btmPt1.Pt) && (p != btmPt1)) p = p.Next;
+        double dx1n = Math.Abs(GetDx(btmPt1.Pt, p.Pt));
+
+        p = btmPt2.Prev;
+        while ((p.Pt == btmPt2.Pt) && (p != btmPt2)) p = p.Prev;
+        double dx2p = Math.Abs(GetDx(btmPt2.Pt, p.Pt));
+        p = btmPt2.Next;
+        while ((p.Pt == btmPt2.Pt) && (p != btmPt2)) p = p.Next;
+        double dx2n = Math.Abs(GetDx(btmPt2.Pt, p.Pt));
+
+        if (Math.Max(dx1p, dx1n) == Math.Max(dx2p, dx2n) &&
+          Math.Min(dx1p, dx1n) == Math.Min(dx2p, dx2n))
+          return Area(btmPt1) > 0; //if otherwise identical use orientation
+        else
+          return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n);
+      }
+      //------------------------------------------------------------------------------
+
+      private OutPt GetBottomPt(OutPt pp)
+      {
+        OutPt dups = null;
+        OutPt p = pp.Next;
+        while (p != pp)
+        {
+          if (p.Pt.Y > pp.Pt.Y)
+          {
+            pp = p;
+            dups = null;
+          }
+          else if (p.Pt.Y == pp.Pt.Y && p.Pt.X <= pp.Pt.X)
+          {
+            if (p.Pt.X < pp.Pt.X)
+            {
+                dups = null;
+                pp = p;
+            } else
+            {
+              if (p.Next != pp && p.Prev != pp) dups = p;
+            }
+          }
+          p = p.Next;
+        }
+        if (dups != null)
+        {
+          //there appears to be at least 2 vertices at bottomPt so ...
+          while (dups != p)
+          {
+            if (!FirstIsBottomPt(p, dups)) pp = dups;
+            dups = dups.Next;
+            while (dups.Pt != pp.Pt) dups = dups.Next;
+          }
+        }
+        return pp;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutRec GetLowermostRec(OutRec outRec1, OutRec outRec2)
+      {
+          //work out which polygon fragment has the correct hole state ...
+          if (outRec1.BottomPt == null) 
+              outRec1.BottomPt = GetBottomPt(outRec1.Pts);
+          if (outRec2.BottomPt == null) 
+              outRec2.BottomPt = GetBottomPt(outRec2.Pts);
+          OutPt bPt1 = outRec1.BottomPt;
+          OutPt bPt2 = outRec2.BottomPt;
+          if (bPt1.Pt.Y > bPt2.Pt.Y) return outRec1;
+          else if (bPt1.Pt.Y < bPt2.Pt.Y) return outRec2;
+          else if (bPt1.Pt.X < bPt2.Pt.X) return outRec1;
+          else if (bPt1.Pt.X > bPt2.Pt.X) return outRec2;
+          else if (bPt1.Next == bPt1) return outRec2;
+          else if (bPt2.Next == bPt2) return outRec1;
+          else if (FirstIsBottomPt(bPt1, bPt2)) return outRec1;
+          else return outRec2;
+      }
+      //------------------------------------------------------------------------------
+
+      bool OutRec1RightOfOutRec2(OutRec outRec1, OutRec outRec2)
+      {
+          do
+          {
+              outRec1 = outRec1.FirstLeft;
+              if (outRec1 == outRec2) return true;
+          } while (outRec1 != null);
+          return false;
+      }
+      //------------------------------------------------------------------------------
+
+      private OutRec GetOutRec(int idx)
+      {
+        OutRec outrec = m_PolyOuts[idx];
+        while (outrec != m_PolyOuts[outrec.Idx])
+          outrec = m_PolyOuts[outrec.Idx];
+        return outrec;
+      }
+      //------------------------------------------------------------------------------
+
+      private void AppendPolygon(TEdge e1, TEdge e2)
+      {
+        OutRec outRec1 = m_PolyOuts[e1.OutIdx];
+        OutRec outRec2 = m_PolyOuts[e2.OutIdx];
+
+        OutRec holeStateRec;
+        if (OutRec1RightOfOutRec2(outRec1, outRec2)) 
+            holeStateRec = outRec2;
+        else if (OutRec1RightOfOutRec2(outRec2, outRec1))
+            holeStateRec = outRec1;
+        else
+            holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+        //get the start and ends of both output polygons and
+        //join E2 poly onto E1 poly and delete pointers to E2 ...
+        OutPt p1_lft = outRec1.Pts;
+        OutPt p1_rt = p1_lft.Prev;
+        OutPt p2_lft = outRec2.Pts;
+        OutPt p2_rt = p2_lft.Prev;
+
+        //join e2 poly onto e1 poly and delete pointers to e2 ...
+        if(  e1.Side == EdgeSide.esLeft )
+        {
+          if (e2.Side == EdgeSide.esLeft)
+          {
+            //z y x a b c
+            ReversePolyPtLinks(p2_lft);
+            p2_lft.Next = p1_lft;
+            p1_lft.Prev = p2_lft;
+            p1_rt.Next = p2_rt;
+            p2_rt.Prev = p1_rt;
+            outRec1.Pts = p2_rt;
+          } else
+          {
+            //x y z a b c
+            p2_rt.Next = p1_lft;
+            p1_lft.Prev = p2_rt;
+            p2_lft.Prev = p1_rt;
+            p1_rt.Next = p2_lft;
+            outRec1.Pts = p2_lft;
+          }
+        } else
+        {
+          if (e2.Side == EdgeSide.esRight)
+          {
+            //a b c z y x
+            ReversePolyPtLinks( p2_lft );
+            p1_rt.Next = p2_rt;
+            p2_rt.Prev = p1_rt;
+            p2_lft.Next = p1_lft;
+            p1_lft.Prev = p2_lft;
+          } else
+          {
+            //a b c x y z
+            p1_rt.Next = p2_lft;
+            p2_lft.Prev = p1_rt;
+            p1_lft.Prev = p2_rt;
+            p2_rt.Next = p1_lft;
+          }
+        }
+
+        outRec1.BottomPt = null; 
+        if (holeStateRec == outRec2)
+        {
+            if (outRec2.FirstLeft != outRec1)
+                outRec1.FirstLeft = outRec2.FirstLeft;
+            outRec1.IsHole = outRec2.IsHole;
+        }
+        outRec2.Pts = null;
+        outRec2.BottomPt = null;
+
+        outRec2.FirstLeft = outRec1;
+
+        int OKIdx = e1.OutIdx;
+        int ObsoleteIdx = e2.OutIdx;
+
+        e1.OutIdx = Unassigned; //nb: safe because we only get here via AddLocalMaxPoly
+        e2.OutIdx = Unassigned;
+
+        TEdge e = m_ActiveEdges;
+        while( e != null )
+        {
+          if( e.OutIdx == ObsoleteIdx )
+          {
+            e.OutIdx = OKIdx;
+            e.Side = e1.Side;
+            break;
+          }
+          e = e.NextInAEL;
+        }
+        outRec2.Idx = outRec1.Idx;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ReversePolyPtLinks(OutPt pp)
+      {
+          if (pp == null) return;
+          OutPt pp1;
+          OutPt pp2;
+          pp1 = pp;
+          do
+          {
+              pp2 = pp1.Next;
+              pp1.Next = pp1.Prev;
+              pp1.Prev = pp2;
+              pp1 = pp2;
+          } while (pp1 != pp);
+      }
+      //------------------------------------------------------------------------------
+
+      private static void SwapSides(TEdge edge1, TEdge edge2)
+      {
+          EdgeSide side = edge1.Side;
+          edge1.Side = edge2.Side;
+          edge2.Side = side;
+      }
+      //------------------------------------------------------------------------------
+
+      private static void SwapPolyIndexes(TEdge edge1, TEdge edge2)
+      {
+          int outIdx = edge1.OutIdx;
+          edge1.OutIdx = edge2.OutIdx;
+          edge2.OutIdx = outIdx;
+      }
+      //------------------------------------------------------------------------------
+
+      private void IntersectEdges(TEdge e1, TEdge e2, IntPoint pt)
+      {
+          //e1 will be to the left of e2 BELOW the intersection. Therefore e1 is before
+          //e2 in AEL except when e1 is being inserted at the intersection point ...
+
+        bool e1Contributing = (e1.OutIdx >= 0);
+        bool e2Contributing = (e2.OutIdx >= 0);
+
+#if use_xyz
+          SetZ(ref pt, e1, e2);
+#endif
+
+#if use_lines
+          //if either edge is on an OPEN path ...
+          if (e1.WindDelta == 0 || e2.WindDelta == 0)
+          {
+            //ignore subject-subject open path intersections UNLESS they
+            //are both open paths, AND they are both 'contributing maximas' ...
+            if (e1.WindDelta == 0 && e2.WindDelta == 0) return;
+            //if intersecting a subj line with a subj poly ...
+            else if (e1.PolyTyp == e2.PolyTyp && 
+              e1.WindDelta != e2.WindDelta && m_ClipType == ClipType.ctUnion)
+            {
+              if (e1.WindDelta == 0)
+              {
+                if (e2Contributing)
+                {
+                  AddOutPt(e1, pt);
+                  if (e1Contributing) e1.OutIdx = Unassigned;
+                }
+              }
+              else
+              {
+                if (e1Contributing)
+                {
+                  AddOutPt(e2, pt);
+                  if (e2Contributing) e2.OutIdx = Unassigned;
+                }
+              }
+            }
+            else if (e1.PolyTyp != e2.PolyTyp)
+            {
+              if ((e1.WindDelta == 0) && Math.Abs(e2.WindCnt) == 1 && 
+                (m_ClipType != ClipType.ctUnion || e2.WindCnt2 == 0))
+              {
+                AddOutPt(e1, pt);
+                if (e1Contributing) e1.OutIdx = Unassigned;
+              }
+              else if ((e2.WindDelta == 0) && (Math.Abs(e1.WindCnt) == 1) && 
+                (m_ClipType != ClipType.ctUnion || e1.WindCnt2 == 0))
+              {
+                AddOutPt(e2, pt);
+                if (e2Contributing) e2.OutIdx = Unassigned;
+              }
+            }
+            return;
+          }
+#endif
+
+          //update winding counts...
+  //assumes that e1 will be to the Right of e2 ABOVE the intersection
+          if (e1.PolyTyp == e2.PolyTyp)
+          {
+              if (IsEvenOddFillType(e1))
+              {
+                  int oldE1WindCnt = e1.WindCnt;
+                  e1.WindCnt = e2.WindCnt;
+                  e2.WindCnt = oldE1WindCnt;
+              }
+              else
+              {
+                  if (e1.WindCnt + e2.WindDelta == 0) e1.WindCnt = -e1.WindCnt;
+                  else e1.WindCnt += e2.WindDelta;
+                  if (e2.WindCnt - e1.WindDelta == 0) e2.WindCnt = -e2.WindCnt;
+                  else e2.WindCnt -= e1.WindDelta;
+              }
+          }
+          else
+          {
+              if (!IsEvenOddFillType(e2)) e1.WindCnt2 += e2.WindDelta;
+              else e1.WindCnt2 = (e1.WindCnt2 == 0) ? 1 : 0;
+              if (!IsEvenOddFillType(e1)) e2.WindCnt2 -= e1.WindDelta;
+              else e2.WindCnt2 = (e2.WindCnt2 == 0) ? 1 : 0;
+          }
+
+          PolyFillType e1FillType, e2FillType, e1FillType2, e2FillType2;
+          if (e1.PolyTyp == PolyType.ptSubject)
+          {
+              e1FillType = m_SubjFillType;
+              e1FillType2 = m_ClipFillType;
+          }
+          else
+          {
+              e1FillType = m_ClipFillType;
+              e1FillType2 = m_SubjFillType;
+          }
+          if (e2.PolyTyp == PolyType.ptSubject)
+          {
+              e2FillType = m_SubjFillType;
+              e2FillType2 = m_ClipFillType;
+          }
+          else
+          {
+              e2FillType = m_ClipFillType;
+              e2FillType2 = m_SubjFillType;
+          }
+
+          int e1Wc, e2Wc;
+          switch (e1FillType)
+          {
+              case PolyFillType.pftPositive: e1Wc = e1.WindCnt; break;
+              case PolyFillType.pftNegative: e1Wc = -e1.WindCnt; break;
+              default: e1Wc = Math.Abs(e1.WindCnt); break;
+          }
+          switch (e2FillType)
+          {
+              case PolyFillType.pftPositive: e2Wc = e2.WindCnt; break;
+              case PolyFillType.pftNegative: e2Wc = -e2.WindCnt; break;
+              default: e2Wc = Math.Abs(e2.WindCnt); break;
+          }
+
+          if (e1Contributing && e2Contributing)
+          {
+            if ((e1Wc != 0 && e1Wc != 1) || (e2Wc != 0 && e2Wc != 1) ||
+              (e1.PolyTyp != e2.PolyTyp && m_ClipType != ClipType.ctXor))
+            {
+              AddLocalMaxPoly(e1, e2, pt);
+            }
+            else
+            {
+              AddOutPt(e1, pt);
+              AddOutPt(e2, pt);
+              SwapSides(e1, e2);
+              SwapPolyIndexes(e1, e2);
+            }
+          }
+          else if (e1Contributing)
+          {
+              if (e2Wc == 0 || e2Wc == 1)
+              {
+                AddOutPt(e1, pt);
+                SwapSides(e1, e2);
+                SwapPolyIndexes(e1, e2);
+              }
+
+          }
+          else if (e2Contributing)
+          {
+              if (e1Wc == 0 || e1Wc == 1)
+              {
+                AddOutPt(e2, pt);
+                SwapSides(e1, e2);
+                SwapPolyIndexes(e1, e2);
+              }
+          }
+          else if ( (e1Wc == 0 || e1Wc == 1) && (e2Wc == 0 || e2Wc == 1))
+          {
+              //neither edge is currently contributing ...
+              cInt e1Wc2, e2Wc2;
+              switch (e1FillType2)
+              {
+                  case PolyFillType.pftPositive: e1Wc2 = e1.WindCnt2; break;
+                  case PolyFillType.pftNegative: e1Wc2 = -e1.WindCnt2; break;
+                  default: e1Wc2 = Math.Abs(e1.WindCnt2); break;
+              }
+              switch (e2FillType2)
+              {
+                  case PolyFillType.pftPositive: e2Wc2 = e2.WindCnt2; break;
+                  case PolyFillType.pftNegative: e2Wc2 = -e2.WindCnt2; break;
+                  default: e2Wc2 = Math.Abs(e2.WindCnt2); break;
+              }
+
+              if (e1.PolyTyp != e2.PolyTyp)
+              {
+                AddLocalMinPoly(e1, e2, pt);
+              }
+              else if (e1Wc == 1 && e2Wc == 1)
+                switch (m_ClipType)
+                {
+                  case ClipType.ctIntersection:
+                    if (e1Wc2 > 0 && e2Wc2 > 0)
+                      AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctUnion:
+                    if (e1Wc2 <= 0 && e2Wc2 <= 0)
+                      AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctDifference:
+                    if (((e1.PolyTyp == PolyType.ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) ||
+                        ((e1.PolyTyp == PolyType.ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0)))
+                          AddLocalMinPoly(e1, e2, pt);
+                    break;
+                  case ClipType.ctXor:
+                    AddLocalMinPoly(e1, e2, pt);
+                    break;
+                }
+              else
+                SwapSides(e1, e2);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DeleteFromSEL(TEdge e)
+      {
+          TEdge SelPrev = e.PrevInSEL;
+          TEdge SelNext = e.NextInSEL;
+          if (SelPrev == null && SelNext == null && (e != m_SortedEdges))
+              return; //already deleted
+          if (SelPrev != null)
+              SelPrev.NextInSEL = SelNext;
+          else m_SortedEdges = SelNext;
+          if (SelNext != null)
+              SelNext.PrevInSEL = SelPrev;
+          e.NextInSEL = null;
+          e.PrevInSEL = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessHorizontals()
+      {
+          TEdge horzEdge; //m_SortedEdges;
+          while (PopEdgeFromSEL(out horzEdge))
+            ProcessHorizontal(horzEdge);
+      }
+      //------------------------------------------------------------------------------
+
+      void GetHorzDirection(TEdge HorzEdge, out Direction Dir, out cInt Left, out cInt Right)
+      {
+        if (HorzEdge.Bot.X < HorzEdge.Top.X)
+        {
+          Left = HorzEdge.Bot.X;
+          Right = HorzEdge.Top.X;
+          Dir = Direction.dLeftToRight;
+        } else
+        {
+          Left = HorzEdge.Top.X;
+          Right = HorzEdge.Bot.X;
+          Dir = Direction.dRightToLeft;
+        }
+      }
+      //------------------------------------------------------------------------
+
+      private void ProcessHorizontal(TEdge horzEdge)
+      {
+        Direction dir;
+        cInt horzLeft, horzRight;
+        bool IsOpen = horzEdge.WindDelta == 0;
+
+        GetHorzDirection(horzEdge, out dir, out horzLeft, out horzRight);
+
+        TEdge eLastHorz = horzEdge, eMaxPair = null;
+        while (eLastHorz.NextInLML != null && IsHorizontal(eLastHorz.NextInLML)) 
+          eLastHorz = eLastHorz.NextInLML;
+        if (eLastHorz.NextInLML == null)
+          eMaxPair = GetMaximaPair(eLastHorz);
+
+        Maxima currMax = m_Maxima;
+        if (currMax != null)
+        {
+            //get the first maxima in range (X) ...
+            if (dir == Direction.dLeftToRight)
+            {
+              while (currMax != null && currMax.X <= horzEdge.Bot.X)
+                  currMax = currMax.Next;
+              if (currMax != null && currMax.X >= eLastHorz.Top.X) 
+                  currMax = null;
+            }
+            else
+            {
+              while (currMax.Next != null && currMax.Next.X < horzEdge.Bot.X) 
+                  currMax = currMax.Next;
+              if (currMax.X <= eLastHorz.Top.X) currMax = null;
+            }
+        }
+
+        OutPt op1 = null;
+        for (;;) //loop through consec. horizontal edges
+        {
+          bool IsLastHorz = (horzEdge == eLastHorz);
+          TEdge e = GetNextInAEL(horzEdge, dir);
+          while(e != null)
+          {
+
+              //this code block inserts extra coords into horizontal edges (in output
+              //polygons) whereever maxima touch these horizontal edges. This helps
+              //'simplifying' polygons (ie if the Simplify property is set).
+              if (currMax != null)
+              {
+                  if (dir == Direction.dLeftToRight)
+                  {
+                      while (currMax != null && currMax.X < e.Curr.X) 
+                      {
+                        if (horzEdge.OutIdx >= 0 && !IsOpen) 
+                          AddOutPt(horzEdge, new IntPoint(currMax.X, horzEdge.Bot.Y));
+                        currMax = currMax.Next;                  
+                      }
+                  }
+                  else
+                  {
+                      while (currMax != null && currMax.X > e.Curr.X)
+                      {
+                          if (horzEdge.OutIdx >= 0 && !IsOpen)
+                            AddOutPt(horzEdge, new IntPoint(currMax.X, horzEdge.Bot.Y));
+                        currMax = currMax.Prev;
+                      }
+                  }
+              };
+
+              if ((dir == Direction.dLeftToRight && e.Curr.X > horzRight) ||
+                (dir == Direction.dRightToLeft && e.Curr.X < horzLeft)) break;
+                                
+              //Also break if we've got to the end of an intermediate horizontal edge ...
+              //nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal.
+              if (e.Curr.X == horzEdge.Top.X && horzEdge.NextInLML != null && 
+                e.Dx < horzEdge.NextInLML.Dx) break;
+
+              if (horzEdge.OutIdx >= 0 && !IsOpen)  //note: may be done multiple times
+              {
+#if use_xyz
+                  if (dir == Direction.dLeftToRight) SetZ(ref e.Curr, horzEdge, e);
+                  else SetZ(ref e.Curr, e, horzEdge);
+#endif
+
+                  op1 = AddOutPt(horzEdge, e.Curr);
+                  TEdge eNextHorz = m_SortedEdges;
+                  while (eNextHorz != null)
+                  {
+                      if (eNextHorz.OutIdx >= 0 &&
+                        HorzSegmentsOverlap(horzEdge.Bot.X,
+                        horzEdge.Top.X, eNextHorz.Bot.X, eNextHorz.Top.X))
+                      {
+                          OutPt op2 = GetLastOutPt(eNextHorz);
+                          AddJoin(op2, op1, eNextHorz.Top);
+                      }
+                      eNextHorz = eNextHorz.NextInSEL;
+                  }
+                  AddGhostJoin(op1, horzEdge.Bot);
+              }
+            
+              //OK, so far we're still in range of the horizontal Edge  but make sure
+              //we're at the last of consec. horizontals when matching with eMaxPair
+              if(e == eMaxPair && IsLastHorz)
+              {
+                if (horzEdge.OutIdx >= 0)
+                  AddLocalMaxPoly(horzEdge, eMaxPair, horzEdge.Top);
+                DeleteFromAEL(horzEdge);
+                DeleteFromAEL(eMaxPair);
+                return;
+              }
+              
+              if(dir == Direction.dLeftToRight)
+              {
+                IntPoint Pt = new IntPoint(e.Curr.X, horzEdge.Curr.Y);
+                IntersectEdges(horzEdge, e, Pt);
+              }
+              else
+              {
+                IntPoint Pt = new IntPoint(e.Curr.X, horzEdge.Curr.Y);
+                IntersectEdges(e, horzEdge, Pt);
+              }
+              TEdge eNext = GetNextInAEL(e, dir);
+              SwapPositionsInAEL(horzEdge, e);
+              e = eNext;
+          } //end while(e != null)
+
+          //Break out of loop if HorzEdge.NextInLML is not also horizontal ...
+          if (horzEdge.NextInLML == null || !IsHorizontal(horzEdge.NextInLML)) break;
+
+          UpdateEdgeIntoAEL(ref horzEdge);
+          if (horzEdge.OutIdx >= 0) AddOutPt(horzEdge, horzEdge.Bot);
+          GetHorzDirection(horzEdge, out dir, out horzLeft, out horzRight);
+
+        } //end for (;;)
+
+        if (horzEdge.OutIdx >= 0 && op1 == null)
+        {
+            op1 = GetLastOutPt(horzEdge);
+            TEdge eNextHorz = m_SortedEdges;
+            while (eNextHorz != null)
+            {
+                if (eNextHorz.OutIdx >= 0 &&
+                  HorzSegmentsOverlap(horzEdge.Bot.X,
+                  horzEdge.Top.X, eNextHorz.Bot.X, eNextHorz.Top.X))
+                {
+                    OutPt op2 = GetLastOutPt(eNextHorz);
+                    AddJoin(op2, op1, eNextHorz.Top);
+                }
+                eNextHorz = eNextHorz.NextInSEL;
+            }
+            AddGhostJoin(op1, horzEdge.Top);
+        }
+
+        if (horzEdge.NextInLML != null)
+        {
+          if(horzEdge.OutIdx >= 0)
+          {
+            op1 = AddOutPt( horzEdge, horzEdge.Top);
+
+            UpdateEdgeIntoAEL(ref horzEdge);
+            if (horzEdge.WindDelta == 0) return;
+            //nb: HorzEdge is no longer horizontal here
+            TEdge ePrev = horzEdge.PrevInAEL;
+            TEdge eNext = horzEdge.NextInAEL;
+            if (ePrev != null && ePrev.Curr.X == horzEdge.Bot.X &&
+              ePrev.Curr.Y == horzEdge.Bot.Y && ePrev.WindDelta != 0 &&
+              (ePrev.OutIdx >= 0 && ePrev.Curr.Y > ePrev.Top.Y &&
+              SlopesEqual(horzEdge, ePrev, m_UseFullRange)))
+            {
+              OutPt op2 = AddOutPt(ePrev, horzEdge.Bot);
+              AddJoin(op1, op2, horzEdge.Top);
+            }
+            else if (eNext != null && eNext.Curr.X == horzEdge.Bot.X &&
+              eNext.Curr.Y == horzEdge.Bot.Y && eNext.WindDelta != 0 &&
+              eNext.OutIdx >= 0 && eNext.Curr.Y > eNext.Top.Y &&
+              SlopesEqual(horzEdge, eNext, m_UseFullRange))
+            {
+              OutPt op2 = AddOutPt(eNext, horzEdge.Bot);
+              AddJoin(op1, op2, horzEdge.Top);
+            }
+          }
+          else
+            UpdateEdgeIntoAEL(ref horzEdge); 
+        }
+        else
+        {
+          if (horzEdge.OutIdx >= 0) AddOutPt(horzEdge, horzEdge.Top);
+          DeleteFromAEL(horzEdge);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private TEdge GetNextInAEL(TEdge e, Direction Direction)
+      {
+          return Direction == Direction.dLeftToRight ? e.NextInAEL: e.PrevInAEL;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsMinima(TEdge e)
+      {
+          return e != null && (e.Prev.NextInLML != e) && (e.Next.NextInLML != e);
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsMaxima(TEdge e, double Y)
+      {
+          return (e != null && e.Top.Y == Y && e.NextInLML == null);
+      }
+      //------------------------------------------------------------------------------
+
+      private bool IsIntermediate(TEdge e, double Y)
+      {
+          return (e.Top.Y == Y && e.NextInLML != null);
+      }
+      //------------------------------------------------------------------------------
+
+      internal TEdge GetMaximaPair(TEdge e)
+      {
+        if ((e.Next.Top == e.Top) && e.Next.NextInLML == null)
+          return e.Next;
+        else if ((e.Prev.Top == e.Top) && e.Prev.NextInLML == null)
+          return e.Prev;
+        else 
+					return null;
+      }
+      //------------------------------------------------------------------------------
+
+      internal TEdge GetMaximaPairEx(TEdge e)
+      {
+        //as above but returns null if MaxPair isn't in AEL (unless it's horizontal)
+        TEdge result = GetMaximaPair(e);
+        if (result == null || result.OutIdx == Skip ||
+          ((result.NextInAEL == result.PrevInAEL) && !IsHorizontal(result))) return null;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool ProcessIntersections(cInt topY)
+      {
+        if( m_ActiveEdges == null ) return true;
+        try {
+          BuildIntersectList(topY);
+          if ( m_IntersectList.Count == 0) return true;
+          if (m_IntersectList.Count == 1 || FixupIntersectionOrder()) 
+              ProcessIntersectList();
+          else 
+              return false;
+        }
+        catch {
+          m_SortedEdges = null;
+          m_IntersectList.Clear();
+          throw new ClipperException("ProcessIntersections error");
+        }
+        m_SortedEdges = null;
+        return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildIntersectList(cInt topY)
+      {
+        if ( m_ActiveEdges == null ) return;
+
+        //prepare for sorting ...
+        TEdge e = m_ActiveEdges;
+        m_SortedEdges = e;
+        while( e != null )
+        {
+          e.PrevInSEL = e.PrevInAEL;
+          e.NextInSEL = e.NextInAEL;
+          e.Curr.X = TopX( e, topY );
+          e = e.NextInAEL;
+        }
+
+        //bubblesort ...
+        bool isModified = true;
+        while( isModified && m_SortedEdges != null )
+        {
+          isModified = false;
+          e = m_SortedEdges;
+          while( e.NextInSEL != null )
+          {
+            TEdge eNext = e.NextInSEL;
+            IntPoint pt;
+            if (e.Curr.X > eNext.Curr.X)
+            {
+                IntersectPoint(e, eNext, out pt);
+                if (pt.Y < topY)
+                  pt = new IntPoint(TopX(e, topY), topY);
+                IntersectNode newNode = new IntersectNode();
+                newNode.Edge1 = e;
+                newNode.Edge2 = eNext;
+                newNode.Pt = pt;
+                m_IntersectList.Add(newNode);
+
+                SwapPositionsInSEL(e, eNext);
+                isModified = true;
+            }
+            else
+              e = eNext;
+          }
+          if( e.PrevInSEL != null ) e.PrevInSEL.NextInSEL = null;
+          else break;
+        }
+        m_SortedEdges = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool EdgesAdjacent(IntersectNode inode)
+      {
+        return (inode.Edge1.NextInSEL == inode.Edge2) ||
+          (inode.Edge1.PrevInSEL == inode.Edge2);
+      }
+      //------------------------------------------------------------------------------
+
+      private static int IntersectNodeSort(IntersectNode node1, IntersectNode node2)
+      {
+        //the following typecast is safe because the differences in Pt.Y will
+        //be limited to the height of the scanbeam.
+        return (int)(node2.Pt.Y - node1.Pt.Y); 
+      }
+      //------------------------------------------------------------------------------
+
+      private bool FixupIntersectionOrder()
+      {
+        //pre-condition: intersections are sorted bottom-most first.
+        //Now it's crucial that intersections are made only between adjacent edges,
+        //so to ensure this the order of intersections may need adjusting ...
+        m_IntersectList.Sort(m_IntersectNodeComparer);
+
+        CopyAELToSEL();
+        int cnt = m_IntersectList.Count;
+        for (int i = 0; i < cnt; i++)
+        {
+          if (!EdgesAdjacent(m_IntersectList[i]))
+          {
+            int j = i + 1;
+            while (j < cnt && !EdgesAdjacent(m_IntersectList[j])) j++;
+            if (j == cnt) return false;
+
+            IntersectNode tmp = m_IntersectList[i];
+            m_IntersectList[i] = m_IntersectList[j];
+            m_IntersectList[j] = tmp;
+
+          }
+          SwapPositionsInSEL(m_IntersectList[i].Edge1, m_IntersectList[i].Edge2);
+        }
+          return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessIntersectList()
+      {
+        for (int i = 0; i < m_IntersectList.Count; i++)
+        {
+          IntersectNode iNode = m_IntersectList[i];
+          {
+            IntersectEdges(iNode.Edge1, iNode.Edge2, iNode.Pt);
+            SwapPositionsInAEL(iNode.Edge1, iNode.Edge2);
+          }
+        }
+        m_IntersectList.Clear();
+      }
+      //------------------------------------------------------------------------------
+
+      internal static cInt Round(double value)
+      {
+          return value < 0 ? (cInt)(value - 0.5) : (cInt)(value + 0.5);
+      }
+      //------------------------------------------------------------------------------
+
+      private static cInt TopX(TEdge edge, cInt currentY)
+      {
+          if (currentY == edge.Top.Y)
+              return edge.Top.X;
+          return edge.Bot.X + Round(edge.Dx *(currentY - edge.Bot.Y));
+      }
+      //------------------------------------------------------------------------------
+
+      private void IntersectPoint(TEdge edge1, TEdge edge2, out IntPoint ip)
+      {
+        ip = new IntPoint();
+        double b1, b2;
+        //nb: with very large coordinate values, it's possible for SlopesEqual() to 
+        //return false but for the edge.Dx value be equal due to double precision rounding.
+        if (edge1.Dx == edge2.Dx)
+        {
+          ip.Y = edge1.Curr.Y;
+          ip.X = TopX(edge1, ip.Y);
+          return;
+        }
+
+        if (edge1.Delta.X == 0)
+        {
+            ip.X = edge1.Bot.X;
+            if (IsHorizontal(edge2))
+            {
+                ip.Y = edge2.Bot.Y;
+            }
+            else
+            {
+                b2 = edge2.Bot.Y - (edge2.Bot.X / edge2.Dx);
+                ip.Y = Round(ip.X / edge2.Dx + b2);
+            }
+        }
+        else if (edge2.Delta.X == 0)
+        {
+            ip.X = edge2.Bot.X;
+            if (IsHorizontal(edge1))
+            {
+                ip.Y = edge1.Bot.Y;
+            }
+            else
+            {
+                b1 = edge1.Bot.Y - (edge1.Bot.X / edge1.Dx);
+                ip.Y = Round(ip.X / edge1.Dx + b1);
+            }
+        }
+        else
+        {
+            b1 = edge1.Bot.X - edge1.Bot.Y * edge1.Dx;
+            b2 = edge2.Bot.X - edge2.Bot.Y * edge2.Dx;
+            double q = (b2 - b1) / (edge1.Dx - edge2.Dx);
+            ip.Y = Round(q);
+            if (Math.Abs(edge1.Dx) < Math.Abs(edge2.Dx))
+                ip.X = Round(edge1.Dx * q + b1);
+            else
+                ip.X = Round(edge2.Dx * q + b2);
+        }
+
+        if (ip.Y < edge1.Top.Y || ip.Y < edge2.Top.Y)
+        {
+          if (edge1.Top.Y > edge2.Top.Y)
+            ip.Y = edge1.Top.Y;
+          else
+            ip.Y = edge2.Top.Y;
+          if (Math.Abs(edge1.Dx) < Math.Abs(edge2.Dx))
+            ip.X = TopX(edge1, ip.Y);
+          else
+            ip.X = TopX(edge2, ip.Y);
+        }
+        //finally, don't allow 'ip' to be BELOW curr.Y (ie bottom of scanbeam) ...
+        if (ip.Y > edge1.Curr.Y)
+        {
+          ip.Y = edge1.Curr.Y;
+          //better to use the more vertical edge to derive X ...
+          if (Math.Abs(edge1.Dx) > Math.Abs(edge2.Dx)) 
+            ip.X = TopX(edge2, ip.Y);
+          else 
+            ip.X = TopX(edge1, ip.Y);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void ProcessEdgesAtTopOfScanbeam(cInt topY)
+      {
+        TEdge e = m_ActiveEdges;
+        while(e != null)
+        {
+          //1. process maxima, treating them as if they're 'bent' horizontal edges,
+          //   but exclude maxima with horizontal edges. nb: e can't be a horizontal.
+          bool IsMaximaEdge = IsMaxima(e, topY);
+
+          if(IsMaximaEdge)
+          {
+            TEdge eMaxPair = GetMaximaPairEx(e);
+            IsMaximaEdge = (eMaxPair == null || !IsHorizontal(eMaxPair));
+          }
+
+          if(IsMaximaEdge)
+          {
+            if (StrictlySimple) InsertMaxima(e.Top.X);
+            TEdge ePrev = e.PrevInAEL;
+            DoMaxima(e);
+            if( ePrev == null) e = m_ActiveEdges;
+            else e = ePrev.NextInAEL;
+          }
+          else
+          {
+            //2. promote horizontal edges, otherwise update Curr.X and Curr.Y ...
+            if (IsIntermediate(e, topY) && IsHorizontal(e.NextInLML))
+            {
+              UpdateEdgeIntoAEL(ref e);
+              if (e.OutIdx >= 0)
+                AddOutPt(e, e.Bot);
+              AddEdgeToSEL(e);
+            } 
+            else
+            {
+              e.Curr.X = TopX( e, topY );
+              e.Curr.Y = topY;
+#if use_xyz
+              if (e.Top.Y == topY) e.Curr.Z = e.Top.Z;
+              else if (e.Bot.Y == topY) e.Curr.Z = e.Bot.Z;
+              else e.Curr.Z = 0;
+#endif
+            }
+            //When StrictlySimple and 'e' is being touched by another edge, then
+            //make sure both edges have a vertex here ...
+            if (StrictlySimple)
+            {
+              TEdge ePrev = e.PrevInAEL;
+              if ((e.OutIdx >= 0) && (e.WindDelta != 0) && ePrev != null &&
+                (ePrev.OutIdx >= 0) && (ePrev.Curr.X == e.Curr.X) &&
+                (ePrev.WindDelta != 0))
+              {
+                IntPoint ip = new IntPoint(e.Curr);
+#if use_xyz
+                SetZ(ref ip, ePrev, e);
+#endif
+                OutPt op = AddOutPt(ePrev, ip);
+                OutPt op2 = AddOutPt(e, ip);
+                AddJoin(op, op2, ip); //StrictlySimple (type-3) join
+              }
+            }
+
+            e = e.NextInAEL;
+          }
+        }
+
+        //3. Process horizontals at the Top of the scanbeam ...
+        ProcessHorizontals();
+        m_Maxima = null;
+
+        //4. Promote intermediate vertices ...
+        e = m_ActiveEdges;
+        while (e != null)
+        {
+          if(IsIntermediate(e, topY))
+          {
+            OutPt op = null;
+            if( e.OutIdx >= 0 ) 
+              op = AddOutPt(e, e.Top);
+            UpdateEdgeIntoAEL(ref e);
+
+            //if output polygons share an edge, they'll need joining later ...
+            TEdge ePrev = e.PrevInAEL;
+            TEdge eNext = e.NextInAEL;
+            if (ePrev != null && ePrev.Curr.X == e.Bot.X &&
+              ePrev.Curr.Y == e.Bot.Y && op != null &&
+              ePrev.OutIdx >= 0 && ePrev.Curr.Y > ePrev.Top.Y &&
+              SlopesEqual(e.Curr, e.Top, ePrev.Curr, ePrev.Top, m_UseFullRange) &&
+              (e.WindDelta != 0) && (ePrev.WindDelta != 0))
+            {
+              OutPt op2 = AddOutPt(ePrev, e.Bot);
+              AddJoin(op, op2, e.Top);
+            }
+            else if (eNext != null && eNext.Curr.X == e.Bot.X &&
+              eNext.Curr.Y == e.Bot.Y && op != null &&
+              eNext.OutIdx >= 0 && eNext.Curr.Y > eNext.Top.Y &&
+              SlopesEqual(e.Curr, e.Top, eNext.Curr, eNext.Top, m_UseFullRange) &&
+              (e.WindDelta != 0) && (eNext.WindDelta != 0))
+            {
+              OutPt op2 = AddOutPt(eNext, e.Bot);
+              AddJoin(op, op2, e.Top);
+            }
+          }
+          e = e.NextInAEL;
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void DoMaxima(TEdge e)
+      {
+        TEdge eMaxPair = GetMaximaPairEx(e);
+        if (eMaxPair == null)
+        {
+          if (e.OutIdx >= 0)
+            AddOutPt(e, e.Top);
+          DeleteFromAEL(e);
+          return;
+        }
+
+        TEdge eNext = e.NextInAEL;
+        while(eNext != null && eNext != eMaxPair)
+        {
+          IntersectEdges(e, eNext, e.Top);
+          SwapPositionsInAEL(e, eNext);
+          eNext = e.NextInAEL;
+        }
+
+        if(e.OutIdx == Unassigned && eMaxPair.OutIdx == Unassigned)
+        {
+          DeleteFromAEL(e);
+          DeleteFromAEL(eMaxPair);
+        }
+        else if( e.OutIdx >= 0 && eMaxPair.OutIdx >= 0 )
+        {
+          if (e.OutIdx >= 0) AddLocalMaxPoly(e, eMaxPair, e.Top);
+          DeleteFromAEL(e);
+          DeleteFromAEL(eMaxPair);
+        }
+#if use_lines
+        else if (e.WindDelta == 0)
+        {
+          if (e.OutIdx >= 0) 
+          {
+            AddOutPt(e, e.Top);
+            e.OutIdx = Unassigned;
+          }
+          DeleteFromAEL(e);
+
+          if (eMaxPair.OutIdx >= 0)
+          {
+            AddOutPt(eMaxPair, e.Top);
+            eMaxPair.OutIdx = Unassigned;
+          }
+          DeleteFromAEL(eMaxPair);
+        } 
+#endif
+        else throw new ClipperException("DoMaxima error");
+      }
+      //------------------------------------------------------------------------------
+
+      public static void ReversePaths(Paths polys)
+      {
+        foreach (var poly in polys) { poly.Reverse(); }
+      }
+      //------------------------------------------------------------------------------
+
+      public static bool Orientation(Path poly)
+      {
+          return Area(poly) >= 0;
+      }
+      //------------------------------------------------------------------------------
+
+      private int PointCount(OutPt pts)
+      {
+          if (pts == null) return 0;
+          int result = 0;
+          OutPt p = pts;
+          do
+          {
+              result++;
+              p = p.Next;
+          }
+          while (p != pts);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildResult(Paths polyg)
+      {
+          polyg.Clear();
+          polyg.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              if (outRec.Pts == null) continue;
+              OutPt p = outRec.Pts.Prev;
+              int cnt = PointCount(p);
+              if (cnt < 2) continue;
+              Path pg = new Path(cnt);
+              for (int j = 0; j < cnt; j++)
+              {
+                  pg.Add(p.Pt);
+                  p = p.Prev;
+              }
+              polyg.Add(pg);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void BuildResult2(PolyTree polytree)
+      {
+          polytree.Clear();
+
+          //add each output polygon/contour to polytree ...
+          polytree.m_AllPolys.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              int cnt = PointCount(outRec.Pts);
+              if ((outRec.IsOpen && cnt < 2) || 
+                (!outRec.IsOpen && cnt < 3)) continue;
+              FixHoleLinkage(outRec);
+              PolyNode pn = new PolyNode();
+              polytree.m_AllPolys.Add(pn);
+              outRec.PolyNode = pn;
+              pn.m_polygon.Capacity = cnt;
+              OutPt op = outRec.Pts.Prev;
+              for (int j = 0; j < cnt; j++)
+              {
+                  pn.m_polygon.Add(op.Pt);
+                  op = op.Prev;
+              }
+          }
+
+          //fixup PolyNode links etc ...
+          polytree.m_Childs.Capacity = m_PolyOuts.Count;
+          for (int i = 0; i < m_PolyOuts.Count; i++)
+          {
+              OutRec outRec = m_PolyOuts[i];
+              if (outRec.PolyNode == null) continue;
+              else if (outRec.IsOpen)
+              {
+                outRec.PolyNode.IsOpen = true;
+                polytree.AddChild(outRec.PolyNode);
+              }
+              else if (outRec.FirstLeft != null && 
+                outRec.FirstLeft.PolyNode != null)
+                  outRec.FirstLeft.PolyNode.AddChild(outRec.PolyNode);
+              else
+                polytree.AddChild(outRec.PolyNode);
+          }
+      }
+      //------------------------------------------------------------------------------
+
+      private void FixupOutPolyline(OutRec outrec)
+      {
+        OutPt pp = outrec.Pts;
+        OutPt lastPP = pp.Prev;
+        while (pp != lastPP)
+        {
+            pp = pp.Next;
+            if (pp.Pt == pp.Prev.Pt)
+            {
+                if (pp == lastPP) lastPP = pp.Prev;
+                OutPt tmpPP = pp.Prev;
+                tmpPP.Next = pp.Next;
+                pp.Next.Prev = tmpPP;
+                pp = tmpPP;
+            }
+        }
+        if (pp == pp.Prev) outrec.Pts = null;
+      }
+      //------------------------------------------------------------------------------
+
+      private void FixupOutPolygon(OutRec outRec)
+      {
+          //FixupOutPolygon() - removes duplicate points and simplifies consecutive
+          //parallel edges by removing the middle vertex.
+          OutPt lastOK = null;
+          outRec.BottomPt = null;
+          OutPt pp = outRec.Pts;
+          bool preserveCol = PreserveCollinear || StrictlySimple;
+          for (;;)
+          {
+              if (pp.Prev == pp || pp.Prev == pp.Next)
+              {
+                  outRec.Pts = null;
+                  return;
+              }
+              //test for duplicate points and collinear edges ...
+              if ((pp.Pt == pp.Next.Pt) || (pp.Pt == pp.Prev.Pt) ||
+                (SlopesEqual(pp.Prev.Pt, pp.Pt, pp.Next.Pt, m_UseFullRange) &&
+                (!preserveCol || !Pt2IsBetweenPt1AndPt3(pp.Prev.Pt, pp.Pt, pp.Next.Pt))))
+              {
+                  lastOK = null;
+                  pp.Prev.Next = pp.Next;
+                  pp.Next.Prev = pp.Prev;
+                  pp = pp.Prev;
+              }
+              else if (pp == lastOK) break;
+              else
+              {
+                  if (lastOK == null) lastOK = pp;
+                  pp = pp.Next;
+              }
+          }
+          outRec.Pts = pp;
+      }
+      //------------------------------------------------------------------------------
+
+      OutPt DupOutPt(OutPt outPt, bool InsertAfter)
+      {
+        OutPt result = new OutPt();
+        result.Pt = outPt.Pt;
+        result.Idx = outPt.Idx;
+        if (InsertAfter)
+        {
+          result.Next = outPt.Next;
+          result.Prev = outPt;
+          outPt.Next.Prev = result;
+          outPt.Next = result;
+        } 
+        else
+        {
+          result.Prev = outPt.Prev;
+          result.Next = outPt;
+          outPt.Prev.Next = result;
+          outPt.Prev = result;
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      bool GetOverlap(cInt a1, cInt a2, cInt b1, cInt b2, out cInt Left, out cInt Right)
+      {
+        if (a1 < a2)
+        {
+          if (b1 < b2) {Left = Math.Max(a1,b1); Right = Math.Min(a2,b2);}
+          else {Left = Math.Max(a1,b2); Right = Math.Min(a2,b1);}
+        } 
+        else
+        {
+          if (b1 < b2) {Left = Math.Max(a2,b1); Right = Math.Min(a1,b2);}
+          else { Left = Math.Max(a2, b2); Right = Math.Min(a1, b1); }
+        }
+        return Left < Right;
+      }
+      //------------------------------------------------------------------------------
+
+      bool JoinHorz(OutPt op1, OutPt op1b, OutPt op2, OutPt op2b, 
+        IntPoint Pt, bool DiscardLeft)
+      {
+        Direction Dir1 = (op1.Pt.X > op1b.Pt.X ? 
+          Direction.dRightToLeft : Direction.dLeftToRight);
+        Direction Dir2 = (op2.Pt.X > op2b.Pt.X ?
+          Direction.dRightToLeft : Direction.dLeftToRight);
+        if (Dir1 == Dir2) return false;
+
+        //When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we
+        //want Op1b to be on the Right. (And likewise with Op2 and Op2b.)
+        //So, to facilitate this while inserting Op1b and Op2b ...
+        //when DiscardLeft, make sure we're AT or RIGHT of Pt before adding Op1b,
+        //otherwise make sure we're AT or LEFT of Pt. (Likewise with Op2b.)
+        if (Dir1 == Direction.dLeftToRight) 
+        {
+          while (op1.Next.Pt.X <= Pt.X && 
+            op1.Next.Pt.X >= op1.Pt.X && op1.Next.Pt.Y == Pt.Y)  
+              op1 = op1.Next;
+          if (DiscardLeft && (op1.Pt.X != Pt.X)) op1 = op1.Next;
+          op1b = DupOutPt(op1, !DiscardLeft);
+          if (op1b.Pt != Pt) 
+          {
+            op1 = op1b;
+            op1.Pt = Pt;
+            op1b = DupOutPt(op1, !DiscardLeft);
+          }
+        } 
+        else
+        {
+          while (op1.Next.Pt.X >= Pt.X && 
+            op1.Next.Pt.X <= op1.Pt.X && op1.Next.Pt.Y == Pt.Y) 
+              op1 = op1.Next;
+          if (!DiscardLeft && (op1.Pt.X != Pt.X)) op1 = op1.Next;
+          op1b = DupOutPt(op1, DiscardLeft);
+          if (op1b.Pt != Pt)
+          {
+            op1 = op1b;
+            op1.Pt = Pt;
+            op1b = DupOutPt(op1, DiscardLeft);
+          }
+        }
+
+        if (Dir2 == Direction.dLeftToRight)
+        {
+          while (op2.Next.Pt.X <= Pt.X && 
+            op2.Next.Pt.X >= op2.Pt.X && op2.Next.Pt.Y == Pt.Y)
+              op2 = op2.Next;
+          if (DiscardLeft && (op2.Pt.X != Pt.X)) op2 = op2.Next;
+          op2b = DupOutPt(op2, !DiscardLeft);
+          if (op2b.Pt != Pt)
+          {
+            op2 = op2b;
+            op2.Pt = Pt;
+            op2b = DupOutPt(op2, !DiscardLeft);
+          };
+        } else
+        {
+          while (op2.Next.Pt.X >= Pt.X && 
+            op2.Next.Pt.X <= op2.Pt.X && op2.Next.Pt.Y == Pt.Y) 
+              op2 = op2.Next;
+          if (!DiscardLeft && (op2.Pt.X != Pt.X)) op2 = op2.Next;
+          op2b = DupOutPt(op2, DiscardLeft);
+          if (op2b.Pt != Pt)
+          {
+            op2 = op2b;
+            op2.Pt = Pt;
+            op2b = DupOutPt(op2, DiscardLeft);
+          };
+        };
+
+        if ((Dir1 == Direction.dLeftToRight) == DiscardLeft)
+        {
+          op1.Prev = op2;
+          op2.Next = op1;
+          op1b.Next = op2b;
+          op2b.Prev = op1b;
+        }
+        else
+        {
+          op1.Next = op2;
+          op2.Prev = op1;
+          op1b.Prev = op2b;
+          op2b.Next = op1b;
+        }
+        return true;
+      }
+      //------------------------------------------------------------------------------
+
+      private bool JoinPoints(Join j, OutRec outRec1, OutRec outRec2)
+      {
+        OutPt op1 = j.OutPt1, op1b;
+        OutPt op2 = j.OutPt2, op2b;
+
+        //There are 3 kinds of joins for output polygons ...
+        //1. Horizontal joins where Join.OutPt1 & Join.OutPt2 are vertices anywhere
+        //along (horizontal) collinear edges (& Join.OffPt is on the same horizontal).
+        //2. Non-horizontal joins where Join.OutPt1 & Join.OutPt2 are at the same
+        //location at the Bottom of the overlapping segment (& Join.OffPt is above).
+        //3. StrictlySimple joins where edges touch but are not collinear and where
+        //Join.OutPt1, Join.OutPt2 & Join.OffPt all share the same point.
+        bool isHorizontal = (j.OutPt1.Pt.Y == j.OffPt.Y);
+
+        if (isHorizontal && (j.OffPt == j.OutPt1.Pt) && (j.OffPt == j.OutPt2.Pt))
+        {          
+          //Strictly Simple join ...
+          if (outRec1 != outRec2) return false;
+          op1b = j.OutPt1.Next;
+          while (op1b != op1 && (op1b.Pt == j.OffPt)) 
+            op1b = op1b.Next;
+          bool reverse1 = (op1b.Pt.Y > j.OffPt.Y);
+          op2b = j.OutPt2.Next;
+          while (op2b != op2 && (op2b.Pt == j.OffPt)) 
+            op2b = op2b.Next;
+          bool reverse2 = (op2b.Pt.Y > j.OffPt.Y);
+          if (reverse1 == reverse2) return false;
+          if (reverse1)
+          {
+            op1b = DupOutPt(op1, false);
+            op2b = DupOutPt(op2, true);
+            op1.Prev = op2;
+            op2.Next = op1;
+            op1b.Next = op2b;
+            op2b.Prev = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          } else
+          {
+            op1b = DupOutPt(op1, true);
+            op2b = DupOutPt(op2, false);
+            op1.Next = op2;
+            op2.Prev = op1;
+            op1b.Prev = op2b;
+            op2b.Next = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          }
+        } 
+        else if (isHorizontal)
+        {
+          //treat horizontal joins differently to non-horizontal joins since with
+          //them we're not yet sure where the overlapping is. OutPt1.Pt & OutPt2.Pt
+          //may be anywhere along the horizontal edge.
+          op1b = op1;
+          while (op1.Prev.Pt.Y == op1.Pt.Y && op1.Prev != op1b && op1.Prev != op2)
+            op1 = op1.Prev;
+          while (op1b.Next.Pt.Y == op1b.Pt.Y && op1b.Next != op1 && op1b.Next != op2)
+            op1b = op1b.Next;
+          if (op1b.Next == op1 || op1b.Next == op2) return false; //a flat 'polygon'
+
+          op2b = op2;
+          while (op2.Prev.Pt.Y == op2.Pt.Y && op2.Prev != op2b && op2.Prev != op1b)
+            op2 = op2.Prev;
+          while (op2b.Next.Pt.Y == op2b.Pt.Y && op2b.Next != op2 && op2b.Next != op1)
+            op2b = op2b.Next;
+          if (op2b.Next == op2 || op2b.Next == op1) return false; //a flat 'polygon'
+
+          cInt Left, Right;
+          //Op1 -. Op1b & Op2 -. Op2b are the extremites of the horizontal edges
+          if (!GetOverlap(op1.Pt.X, op1b.Pt.X, op2.Pt.X, op2b.Pt.X, out Left, out Right))
+            return false;
+
+          //DiscardLeftSide: when overlapping edges are joined, a spike will created
+          //which needs to be cleaned up. However, we don't want Op1 or Op2 caught up
+          //on the discard Side as either may still be needed for other joins ...
+          IntPoint Pt;
+          bool DiscardLeftSide;
+          if (op1.Pt.X >= Left && op1.Pt.X <= Right) 
+          {
+            Pt = op1.Pt; DiscardLeftSide = (op1.Pt.X > op1b.Pt.X);
+          } 
+          else if (op2.Pt.X >= Left&& op2.Pt.X <= Right) 
+          {
+            Pt = op2.Pt; DiscardLeftSide = (op2.Pt.X > op2b.Pt.X);
+          } 
+          else if (op1b.Pt.X >= Left && op1b.Pt.X <= Right)
+          {
+            Pt = op1b.Pt; DiscardLeftSide = op1b.Pt.X > op1.Pt.X;
+          } 
+          else
+          {
+            Pt = op2b.Pt; DiscardLeftSide = (op2b.Pt.X > op2.Pt.X);
+          }
+          j.OutPt1 = op1;
+          j.OutPt2 = op2;
+          return JoinHorz(op1, op1b, op2, op2b, Pt, DiscardLeftSide);
+        } else
+        {
+          //nb: For non-horizontal joins ...
+          //    1. Jr.OutPt1.Pt.Y == Jr.OutPt2.Pt.Y
+          //    2. Jr.OutPt1.Pt > Jr.OffPt.Y
+
+          //make sure the polygons are correctly oriented ...
+          op1b = op1.Next;
+          while ((op1b.Pt == op1.Pt) && (op1b != op1)) op1b = op1b.Next;
+          bool Reverse1 = ((op1b.Pt.Y > op1.Pt.Y) ||
+            !SlopesEqual(op1.Pt, op1b.Pt, j.OffPt, m_UseFullRange));
+          if (Reverse1)
+          {
+            op1b = op1.Prev;
+            while ((op1b.Pt == op1.Pt) && (op1b != op1)) op1b = op1b.Prev;
+            if ((op1b.Pt.Y > op1.Pt.Y) ||
+              !SlopesEqual(op1.Pt, op1b.Pt, j.OffPt, m_UseFullRange)) return false;
+          };
+          op2b = op2.Next;
+          while ((op2b.Pt == op2.Pt) && (op2b != op2)) op2b = op2b.Next;
+          bool Reverse2 = ((op2b.Pt.Y > op2.Pt.Y) ||
+            !SlopesEqual(op2.Pt, op2b.Pt, j.OffPt, m_UseFullRange));
+          if (Reverse2)
+          {
+            op2b = op2.Prev;
+            while ((op2b.Pt == op2.Pt) && (op2b != op2)) op2b = op2b.Prev;
+            if ((op2b.Pt.Y > op2.Pt.Y) ||
+              !SlopesEqual(op2.Pt, op2b.Pt, j.OffPt, m_UseFullRange)) return false;
+          }
+
+          if ((op1b == op1) || (op2b == op2) || (op1b == op2b) ||
+            ((outRec1 == outRec2) && (Reverse1 == Reverse2))) return false;
+
+          if (Reverse1)
+          {
+            op1b = DupOutPt(op1, false);
+            op2b = DupOutPt(op2, true);
+            op1.Prev = op2;
+            op2.Next = op1;
+            op1b.Next = op2b;
+            op2b.Prev = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          } else
+          {
+            op1b = DupOutPt(op1, true);
+            op2b = DupOutPt(op2, false);
+            op1.Next = op2;
+            op2.Prev = op1;
+            op1b.Prev = op2b;
+            op2b.Next = op1b;
+            j.OutPt1 = op1;
+            j.OutPt2 = op1b;
+            return true;
+          }
+        }
+      }
+      //----------------------------------------------------------------------
+
+      public static int PointInPolygon(IntPoint pt, Path path)
+      {
+        //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+        //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos
+        //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
+        int result = 0, cnt = path.Count;
+        if (cnt < 3) return 0;
+        IntPoint ip = path[0];
+        for (int i = 1; i <= cnt; ++i)
+        {
+          IntPoint ipNext = (i == cnt ? path[0] : path[i]);
+          if (ipNext.Y == pt.Y)
+          {
+            if ((ipNext.X == pt.X) || (ip.Y == pt.Y &&
+              ((ipNext.X > pt.X) == (ip.X < pt.X)))) return -1;
+          }
+          if ((ip.Y < pt.Y) != (ipNext.Y < pt.Y))
+          {
+            if (ip.X >= pt.X)
+            {
+              if (ipNext.X > pt.X) result = 1 - result;
+              else
+              {
+                double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                  (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+                if (d == 0) return -1;
+                else if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result;
+              }
+            }
+            else
+            {
+              if (ipNext.X > pt.X)
+              {
+                double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                  (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+                if (d == 0) return -1;
+                else if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result;
+              }
+            }
+          }
+          ip = ipNext;
+        }
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos
+      //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
+      private static int PointInPolygon(IntPoint pt, OutPt op)
+      {
+        //returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+        int result = 0;
+        OutPt startOp = op;
+        cInt ptx = pt.X, pty = pt.Y;
+        cInt poly0x = op.Pt.X, poly0y = op.Pt.Y;
+        do
+        {
+          op = op.Next;
+          cInt poly1x = op.Pt.X, poly1y = op.Pt.Y;
+
+          if (poly1y == pty)
+          {
+            if ((poly1x == ptx) || (poly0y == pty &&
+              ((poly1x > ptx) == (poly0x < ptx)))) return -1;
+          }
+          if ((poly0y < pty) != (poly1y < pty))
+          {
+            if (poly0x >= ptx)
+            {
+              if (poly1x > ptx) result = 1 - result;
+              else
+              {
+                double d = (double)(poly0x - ptx) * (poly1y - pty) -
+                  (double)(poly1x - ptx) * (poly0y - pty);
+                if (d == 0) return -1;
+                if ((d > 0) == (poly1y > poly0y)) result = 1 - result;
+              }
+            }
+            else
+            {
+              if (poly1x > ptx)
+              {
+                double d = (double)(poly0x - ptx) * (poly1y - pty) -
+                  (double)(poly1x - ptx) * (poly0y - pty);
+                if (d == 0) return -1;
+                if ((d > 0) == (poly1y > poly0y)) result = 1 - result;
+              }
+            }
+          }
+          poly0x = poly1x; poly0y = poly1y;
+        } while (startOp != op);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private static bool Poly2ContainsPoly1(OutPt outPt1, OutPt outPt2)
+      {
+        OutPt op = outPt1;
+        do
+        {
+          //nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon
+          int res = PointInPolygon(op.Pt, outPt2);
+          if (res >= 0) return res > 0;
+          op = op.Next;
+        }
+        while (op != outPt1);
+        return true;
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts1(OutRec OldOutRec, OutRec NewOutRec)
+      { 
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (outRec.Pts != null && firstLeft == OldOutRec)
+          {
+            if (Poly2ContainsPoly1(outRec.Pts, NewOutRec.Pts))
+                outRec.FirstLeft = NewOutRec;
+          }
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts2(OutRec innerOutRec, OutRec outerOutRec)
+      {
+        //A polygon has split into two such that one is now the inner of the other.
+        //It's possible that these polygons now wrap around other polygons, so check
+        //every polygon that's also contained by OuterOutRec's FirstLeft container
+        //(including nil) to see if they've become inner to the new inner polygon ...
+        OutRec orfl = outerOutRec.FirstLeft;
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          if (outRec.Pts == null || outRec == outerOutRec || outRec == innerOutRec) 
+            continue;
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (firstLeft != orfl && firstLeft != innerOutRec && firstLeft != outerOutRec) 
+            continue;
+          if (Poly2ContainsPoly1(outRec.Pts, innerOutRec.Pts))
+            outRec.FirstLeft = innerOutRec;
+          else if (Poly2ContainsPoly1(outRec.Pts, outerOutRec.Pts))
+            outRec.FirstLeft = outerOutRec;
+          else if (outRec.FirstLeft == innerOutRec || outRec.FirstLeft == outerOutRec) 
+            outRec.FirstLeft = orfl;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private void FixupFirstLefts3(OutRec OldOutRec, OutRec NewOutRec)
+      {
+        //same as FixupFirstLefts1 but doesn't call Poly2ContainsPoly1()
+        foreach (OutRec outRec in m_PolyOuts)
+        {
+          OutRec firstLeft = ParseFirstLeft(outRec.FirstLeft);
+          if (outRec.Pts != null && firstLeft == OldOutRec) 
+            outRec.FirstLeft = NewOutRec;
+        }
+      }
+      //----------------------------------------------------------------------
+
+      private static OutRec ParseFirstLeft(OutRec FirstLeft)
+      {
+        while (FirstLeft != null && FirstLeft.Pts == null) 
+          FirstLeft = FirstLeft.FirstLeft;
+        return FirstLeft;
+      }
+      //------------------------------------------------------------------------------
+
+    private void JoinCommonEdges()
+      {
+        for (int i = 0; i < m_Joins.Count; i++)
+        {
+          Join join = m_Joins[i];
+
+          OutRec outRec1 = GetOutRec(join.OutPt1.Idx);
+          OutRec outRec2 = GetOutRec(join.OutPt2.Idx);
+
+          if (outRec1.Pts == null || outRec2.Pts == null) continue;
+          if (outRec1.IsOpen || outRec2.IsOpen) continue;
+
+          //get the polygon fragment with the correct hole state (FirstLeft)
+          //before calling JoinPoints() ...
+          OutRec holeStateRec;
+          if (outRec1 == outRec2) holeStateRec = outRec1;
+          else if (OutRec1RightOfOutRec2(outRec1, outRec2)) holeStateRec = outRec2;
+          else if (OutRec1RightOfOutRec2(outRec2, outRec1)) holeStateRec = outRec1;
+          else holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+          if (!JoinPoints(join, outRec1, outRec2)) continue;
+
+          if (outRec1 == outRec2)
+          {
+            //instead of joining two polygons, we've just created a new one by
+            //splitting one polygon into two.
+            outRec1.Pts = join.OutPt1;
+            outRec1.BottomPt = null;
+            outRec2 = CreateOutRec();
+            outRec2.Pts = join.OutPt2;
+
+            //update all OutRec2.Pts Idx's ...
+            UpdateOutPtIdxs(outRec2);
+
+            if (Poly2ContainsPoly1(outRec2.Pts, outRec1.Pts))
+            {
+              //outRec1 contains outRec2 ...
+              outRec2.IsHole = !outRec1.IsHole;
+              outRec2.FirstLeft = outRec1;
+
+              if (m_UsingPolyTree) FixupFirstLefts2(outRec2, outRec1);
+
+              if ((outRec2.IsHole ^ ReverseSolution) == (Area(outRec2) > 0))
+                ReversePolyPtLinks(outRec2.Pts);
+
+            }
+            else if (Poly2ContainsPoly1(outRec1.Pts, outRec2.Pts))
+            {
+              //outRec2 contains outRec1 ...
+              outRec2.IsHole = outRec1.IsHole;
+              outRec1.IsHole = !outRec2.IsHole;
+              outRec2.FirstLeft = outRec1.FirstLeft;
+              outRec1.FirstLeft = outRec2;
+
+              if (m_UsingPolyTree) FixupFirstLefts2(outRec1, outRec2);
+
+              if ((outRec1.IsHole ^ ReverseSolution) == (Area(outRec1) > 0))
+                ReversePolyPtLinks(outRec1.Pts);
+            }
+            else
+            {
+              //the 2 polygons are completely separate ...
+              outRec2.IsHole = outRec1.IsHole;
+              outRec2.FirstLeft = outRec1.FirstLeft;
+
+              //fixup FirstLeft pointers that may need reassigning to OutRec2
+              if (m_UsingPolyTree) FixupFirstLefts1(outRec1, outRec2);
+            }
+     
+          } else
+          {
+            //joined 2 polygons together ...
+
+            outRec2.Pts = null;
+            outRec2.BottomPt = null;
+            outRec2.Idx = outRec1.Idx;
+
+            outRec1.IsHole = holeStateRec.IsHole;
+            if (holeStateRec == outRec2) 
+              outRec1.FirstLeft = outRec2.FirstLeft;
+            outRec2.FirstLeft = outRec1;
+
+            //fixup FirstLeft pointers that may need reassigning to OutRec1
+            if (m_UsingPolyTree) FixupFirstLefts3(outRec2, outRec1);
+          }
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      private void UpdateOutPtIdxs(OutRec outrec)
+      {  
+        OutPt op = outrec.Pts;
+        do
+        {
+          op.Idx = outrec.Idx;
+          op = op.Prev;
+        }
+        while(op != outrec.Pts);
+      }
+      //------------------------------------------------------------------------------
+
+      private void DoSimplePolygons()
+      {
+        int i = 0;
+        while (i < m_PolyOuts.Count) 
+        {
+          OutRec outrec = m_PolyOuts[i++];
+          OutPt op = outrec.Pts;
+          if (op == null || outrec.IsOpen) continue;
+          do //for each Pt in Polygon until duplicate found do ...
+          {
+            OutPt op2 = op.Next;
+            while (op2 != outrec.Pts) 
+            {
+              if ((op.Pt == op2.Pt) && op2.Next != op && op2.Prev != op) 
+              {
+                //split the polygon into two ...
+                OutPt op3 = op.Prev;
+                OutPt op4 = op2.Prev;
+                op.Prev = op4;
+                op4.Next = op;
+                op2.Prev = op3;
+                op3.Next = op2;
+
+                outrec.Pts = op;
+                OutRec outrec2 = CreateOutRec();
+                outrec2.Pts = op2;
+                UpdateOutPtIdxs(outrec2);
+                if (Poly2ContainsPoly1(outrec2.Pts, outrec.Pts))
+                {
+                  //OutRec2 is contained by OutRec1 ...
+                  outrec2.IsHole = !outrec.IsHole;
+                  outrec2.FirstLeft = outrec;
+                  if (m_UsingPolyTree) FixupFirstLefts2(outrec2, outrec);
+                }
+                else
+                  if (Poly2ContainsPoly1(outrec.Pts, outrec2.Pts))
+                {
+                  //OutRec1 is contained by OutRec2 ...
+                  outrec2.IsHole = outrec.IsHole;
+                  outrec.IsHole = !outrec2.IsHole;
+                  outrec2.FirstLeft = outrec.FirstLeft;
+                  outrec.FirstLeft = outrec2;
+                  if (m_UsingPolyTree) FixupFirstLefts2(outrec, outrec2);
+                }
+                  else
+                {
+                  //the 2 polygons are separate ...
+                  outrec2.IsHole = outrec.IsHole;
+                  outrec2.FirstLeft = outrec.FirstLeft;
+                  if (m_UsingPolyTree) FixupFirstLefts1(outrec, outrec2);
+                }
+                op2 = op; //ie get ready for the next iteration
+              }
+              op2 = op2.Next;
+            }
+            op = op.Next;
+          }
+          while (op != outrec.Pts);
+        }
+      }
+      //------------------------------------------------------------------------------
+
+      public static double Area(Path poly)
+      {
+        int cnt = (int)poly.Count;
+        if (cnt < 3) return 0;
+        double a = 0;
+        for (int i = 0, j = cnt - 1; i < cnt; ++i)
+        {
+          a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y);
+          j = i;
+        }
+        return -a * 0.5;
+      }
+      //------------------------------------------------------------------------------
+
+      internal double Area(OutRec outRec)
+      {
+        return Area(outRec.Pts);
+      }
+      //------------------------------------------------------------------------------
+
+      internal double Area(OutPt op)
+      {
+        OutPt opFirst = op;
+        if (op == null) return 0;
+        double a = 0;
+        do {
+          a = a + (double)(op.Prev.Pt.X + op.Pt.X) * (double)(op.Prev.Pt.Y - op.Pt.Y);
+          op = op.Next;
+        } while (op != opFirst);
+        return a * 0.5;
+      }
+
+      //------------------------------------------------------------------------------
+      // SimplifyPolygon functions ...
+      // Convert self-intersecting polygons into simple polygons
+      //------------------------------------------------------------------------------
+
+      public static Paths SimplifyPolygon(Path poly, 
+            PolyFillType fillType = PolyFillType.pftEvenOdd)
+      {
+          Paths result = new Paths();
+          Clipper c = new Clipper();
+          c.StrictlySimple = true;
+          c.AddPath(poly, PolyType.ptSubject, true);
+          c.Execute(ClipType.ctUnion, result, fillType, fillType);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths SimplifyPolygons(Paths polys,
+          PolyFillType fillType = PolyFillType.pftEvenOdd)
+      {
+          Paths result = new Paths();
+          Clipper c = new Clipper();
+          c.StrictlySimple = true;
+          c.AddPaths(polys, PolyType.ptSubject, true);
+          c.Execute(ClipType.ctUnion, result, fillType, fillType);
+          return result;
+      }
+      //------------------------------------------------------------------------------
+
+      private static double DistanceSqrd(IntPoint pt1, IntPoint pt2)
+      {
+        double dx = ((double)pt1.X - pt2.X);
+        double dy = ((double)pt1.Y - pt2.Y);
+        return (dx*dx + dy*dy);
+      }
+      //------------------------------------------------------------------------------
+
+      private static double DistanceFromLineSqrd(IntPoint pt, IntPoint ln1, IntPoint ln2)
+      {
+        //The equation of a line in general form (Ax + By + C = 0)
+        //given 2 points (x¹,y¹) & (x²,y²) is ...
+        //(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0
+        //A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹
+        //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²)
+        //see http://en.wikipedia.org/wiki/Perpendicular_distance
+        double A = ln1.Y - ln2.Y;
+        double B = ln2.X - ln1.X;
+        double C = A * ln1.X  + B * ln1.Y;
+        C = A * pt.X + B * pt.Y - C;
+        return (C * C) / (A * A + B * B);
+      }
+      //---------------------------------------------------------------------------
+
+      private static bool SlopesNearCollinear(IntPoint pt1, 
+          IntPoint pt2, IntPoint pt3, double distSqrd)
+      {
+        //this function is more accurate when the point that's GEOMETRICALLY 
+        //between the other 2 points is the one that's tested for distance.  
+        //nb: with 'spikes', either pt1 or pt3 is geometrically between the other pts                    
+        if (Math.Abs(pt1.X - pt2.X) > Math.Abs(pt1.Y - pt2.Y))
+	      {
+          if ((pt1.X > pt2.X) == (pt1.X < pt3.X))
+            return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+          else if ((pt2.X > pt1.X) == (pt2.X < pt3.X))
+            return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+		      else
+	          return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+	      }
+	      else
+	      {
+          if ((pt1.Y > pt2.Y) == (pt1.Y < pt3.Y))
+            return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+          else if ((pt2.Y > pt1.Y) == (pt2.Y < pt3.Y))
+            return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+		      else
+            return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+	      }
+      }
+      //------------------------------------------------------------------------------
+
+      private static bool PointsAreClose(IntPoint pt1, IntPoint pt2, double distSqrd)
+      {
+          double dx = (double)pt1.X - pt2.X;
+          double dy = (double)pt1.Y - pt2.Y;
+          return ((dx * dx) + (dy * dy) <= distSqrd);
+      }
+      //------------------------------------------------------------------------------
+
+      private static OutPt ExcludeOp(OutPt op)
+      {
+        OutPt result = op.Prev;
+        result.Next = op.Next;
+        op.Next.Prev = result;
+        result.Idx = 0;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Path CleanPolygon(Path path, double distance = 1.415)
+      {
+        //distance = proximity in units/pixels below which vertices will be stripped. 
+        //Default ~= sqrt(2) so when adjacent vertices or semi-adjacent vertices have 
+        //both x & y coords within 1 unit, then the second vertex will be stripped.
+
+        int cnt = path.Count;
+
+        if (cnt == 0) return new Path();
+
+        OutPt [] outPts = new OutPt[cnt];
+        for (int i = 0; i < cnt; ++i) outPts[i] = new OutPt();
+
+        for (int i = 0; i < cnt; ++i)
+        {
+          outPts[i].Pt = path[i];
+          outPts[i].Next = outPts[(i + 1) % cnt];
+          outPts[i].Next.Prev = outPts[i];
+          outPts[i].Idx = 0;
+        }
+
+        double distSqrd = distance * distance;
+        OutPt op = outPts[0];
+        while (op.Idx == 0 && op.Next != op.Prev)
+        {
+          if (PointsAreClose(op.Pt, op.Prev.Pt, distSqrd))
+          {
+            op = ExcludeOp(op);
+            cnt--;
+          }
+          else if (PointsAreClose(op.Prev.Pt, op.Next.Pt, distSqrd))
+          {
+            ExcludeOp(op.Next);
+            op = ExcludeOp(op);
+            cnt -= 2;
+          }
+          else if (SlopesNearCollinear(op.Prev.Pt, op.Pt, op.Next.Pt, distSqrd))
+          {
+            op = ExcludeOp(op);
+            cnt--;
+          }
+          else
+          {
+            op.Idx = 1;
+            op = op.Next;
+          }
+        }
+
+        if (cnt < 3) cnt = 0;
+        Path result = new Path(cnt);
+        for (int i = 0; i < cnt; ++i)
+        {
+          result.Add(op.Pt);
+          op = op.Next;
+        }
+        outPts = null;
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths CleanPolygons(Paths polys,
+          double distance = 1.415)
+      {
+        Paths result = new Paths(polys.Count);
+        for (int i = 0; i < polys.Count; i++)
+          result.Add(CleanPolygon(polys[i], distance));
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      internal static Paths Minkowski(Path pattern, Path path, bool IsSum, bool IsClosed)
+      {
+        int delta = (IsClosed ? 1 : 0);
+        int polyCnt = pattern.Count;
+        int pathCnt = path.Count;
+        Paths result = new Paths(pathCnt);
+        if (IsSum)
+          for (int i = 0; i < pathCnt; i++)
+          {
+            Path p = new Path(polyCnt);
+            foreach (IntPoint ip in pattern)
+              p.Add(new IntPoint(path[i].X + ip.X, path[i].Y + ip.Y));
+            result.Add(p);
+          }
+        else
+          for (int i = 0; i < pathCnt; i++)
+          {
+            Path p = new Path(polyCnt);
+            foreach (IntPoint ip in pattern)
+              p.Add(new IntPoint(path[i].X - ip.X, path[i].Y - ip.Y));
+            result.Add(p);
+          }
+
+        Paths quads = new Paths((pathCnt + delta) * (polyCnt + 1));
+        for (int i = 0; i < pathCnt - 1 + delta; i++)
+          for (int j = 0; j < polyCnt; j++)
+          {
+            Path quad = new Path(4);
+            quad.Add(result[i % pathCnt][j % polyCnt]);
+            quad.Add(result[(i + 1) % pathCnt][j % polyCnt]);
+            quad.Add(result[(i + 1) % pathCnt][(j + 1) % polyCnt]);
+            quad.Add(result[i % pathCnt][(j + 1) % polyCnt]);
+            if (!Orientation(quad)) quad.Reverse();
+            quads.Add(quad);
+          }
+        return quads;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiSum(Path pattern, Path path, bool pathIsClosed)
+      {
+        Paths paths = Minkowski(pattern, path, true, pathIsClosed);
+        Clipper c = new Clipper();
+        c.AddPaths(paths, PolyType.ptSubject, true);
+        c.Execute(ClipType.ctUnion, paths, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return paths;
+      }
+      //------------------------------------------------------------------------------
+
+      private static Path TranslatePath(Path path, IntPoint delta) 
+      {
+        Path outPath = new Path(path.Count);
+        for (int i = 0; i < path.Count; i++)
+          outPath.Add(new IntPoint(path[i].X + delta.X, path[i].Y + delta.Y));
+        return outPath;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiSum(Path pattern, Paths paths, bool pathIsClosed)
+      {
+        Paths solution = new Paths();
+        Clipper c = new Clipper();
+        for (int i = 0; i < paths.Count; ++i)
+        {
+          Paths tmp = Minkowski(pattern, paths[i], true, pathIsClosed);
+          c.AddPaths(tmp, PolyType.ptSubject, true);
+          if (pathIsClosed)
+          {
+            Path path = TranslatePath(paths[i], pattern[0]);
+            c.AddPath(path, PolyType.ptClip, true);
+          }
+        }
+        c.Execute(ClipType.ctUnion, solution, 
+          PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return solution;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths MinkowskiDiff(Path poly1, Path poly2)
+      {
+        Paths paths = Minkowski(poly1, poly2, false, true);
+        Clipper c = new Clipper();
+        c.AddPaths(paths, PolyType.ptSubject, true);
+        c.Execute(ClipType.ctUnion, paths, PolyFillType.pftNonZero, PolyFillType.pftNonZero);
+        return paths;
+      }
+      //------------------------------------------------------------------------------
+
+      internal enum NodeType { ntAny, ntOpen, ntClosed };
+
+      public static Paths PolyTreeToPaths(PolyTree polytree)
+      {
+
+        Paths result = new Paths();
+        result.Capacity = polytree.Total;
+        AddPolyNodeToPaths(polytree, NodeType.ntAny, result);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      internal static void AddPolyNodeToPaths(PolyNode polynode, NodeType nt, Paths paths)
+      {
+        bool match = true;
+        switch (nt)
+        {
+          case NodeType.ntOpen: return;
+          case NodeType.ntClosed: match = !polynode.IsOpen; break;
+          default: break;
+        }
+
+        if (polynode.m_polygon.Count > 0 && match)
+          paths.Add(polynode.m_polygon);
+        foreach (PolyNode pn in polynode.Childs)
+          AddPolyNodeToPaths(pn, nt, paths);
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths OpenPathsFromPolyTree(PolyTree polytree)
+      {
+        Paths result = new Paths();
+        result.Capacity = polytree.ChildCount;
+        for (int i = 0; i < polytree.ChildCount; i++)
+          if (polytree.Childs[i].IsOpen)
+            result.Add(polytree.Childs[i].m_polygon);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+      public static Paths ClosedPathsFromPolyTree(PolyTree polytree)
+      {
+        Paths result = new Paths();
+        result.Capacity = polytree.Total;
+        AddPolyNodeToPaths(polytree, NodeType.ntClosed, result);
+        return result;
+      }
+      //------------------------------------------------------------------------------
+
+  } //end Clipper
+
+  internal class ClipperOffset
+  {
+    private Paths m_destPolys;
+    private Path m_srcPoly;
+    private Path m_destPoly;
+    private List<DoublePoint> m_normals = new List<DoublePoint>();
+    private double m_delta, m_sinA, m_sin, m_cos;
+    private double m_miterLim, m_StepsPerRad;
+
+    private IntPoint m_lowest;
+    private PolyNode m_polyNodes = new PolyNode();
+
+    public double ArcTolerance { get; set; }
+    public double MiterLimit { get; set; }
+
+    private const double two_pi = Math.PI * 2;
+    private const double def_arc_tolerance = 0.25;
+
+    public ClipperOffset(
+      double miterLimit = 2.0, double arcTolerance = def_arc_tolerance)
+    {
+      MiterLimit = miterLimit;
+      ArcTolerance = arcTolerance;
+      m_lowest.X = -1;
+    }
+    //------------------------------------------------------------------------------
+
+    public void Clear()
+    {
+      m_polyNodes.Childs.Clear();
+      m_lowest.X = -1;
+    }
+    //------------------------------------------------------------------------------
+
+    internal static cInt Round(double value)
+    {
+      return value < 0 ? (cInt)(value - 0.5) : (cInt)(value + 0.5);
+    }
+    //------------------------------------------------------------------------------
+
+    public void AddPath(Path path, JoinType joinType, EndType endType)
+    {
+      int highI = path.Count - 1;
+      if (highI < 0) return;
+      PolyNode newNode = new PolyNode();
+      newNode.m_jointype = joinType;
+      newNode.m_endtype = endType;
+
+      //strip duplicate points from path and also get index to the lowest point ...
+      if (endType == EndType.etClosedLine || endType == EndType.etClosedPolygon)
+        while (highI > 0 && path[0] == path[highI]) highI--;
+      newNode.m_polygon.Capacity = highI + 1;
+      newNode.m_polygon.Add(path[0]);
+      int j = 0, k = 0;
+      for (int i = 1; i <= highI; i++)
+        if (newNode.m_polygon[j] != path[i])
+        {
+          j++;
+          newNode.m_polygon.Add(path[i]);
+          if (path[i].Y > newNode.m_polygon[k].Y ||
+            (path[i].Y == newNode.m_polygon[k].Y &&
+            path[i].X < newNode.m_polygon[k].X)) k = j;
+        }
+      if (endType == EndType.etClosedPolygon && j < 2) return;
+
+      m_polyNodes.AddChild(newNode);
+
+      //if this path's lowest pt is lower than all the others then update m_lowest
+      if (endType != EndType.etClosedPolygon) return;
+      if (m_lowest.X < 0)
+        m_lowest = new IntPoint(m_polyNodes.ChildCount - 1, k);
+      else
+      {
+        IntPoint ip = m_polyNodes.Childs[(int)m_lowest.X].m_polygon[(int)m_lowest.Y];
+        if (newNode.m_polygon[k].Y > ip.Y ||
+          (newNode.m_polygon[k].Y == ip.Y &&
+          newNode.m_polygon[k].X < ip.X))
+          m_lowest = new IntPoint(m_polyNodes.ChildCount - 1, k);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void AddPaths(Paths paths, JoinType joinType, EndType endType)
+    {
+      foreach (Path p in paths)
+        AddPath(p, joinType, endType);
+    }
+    //------------------------------------------------------------------------------
+
+    private void FixOrientations()
+    {
+      //fixup orientations of all closed paths if the orientation of the
+      //closed path with the lowermost vertex is wrong ...
+      if (m_lowest.X >= 0 && 
+        !Clipper.Orientation(m_polyNodes.Childs[(int)m_lowest.X].m_polygon))
+      {
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedPolygon ||
+            (node.m_endtype == EndType.etClosedLine && 
+            Clipper.Orientation(node.m_polygon)))
+            node.m_polygon.Reverse();
+        }
+      }
+      else
+      {
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedLine &&
+            !Clipper.Orientation(node.m_polygon))
+          node.m_polygon.Reverse();
+        }
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    internal static DoublePoint GetUnitNormal(IntPoint pt1, IntPoint pt2)
+    {
+      double dx = (pt2.X - pt1.X);
+      double dy = (pt2.Y - pt1.Y);
+      if ((dx == 0) && (dy == 0)) return new DoublePoint();
+
+      double f = 1 * 1.0 / Math.Sqrt(dx * dx + dy * dy);
+      dx *= f;
+      dy *= f;
+
+      return new DoublePoint(dy, -dx);
+    }
+    //------------------------------------------------------------------------------
+
+    private void DoOffset(double delta)
+    {
+      m_destPolys = new Paths();
+      m_delta = delta;
+
+      //if Zero offset, just copy any CLOSED polygons to m_p and return ...
+      if (ClipperBase.near_zero(delta)) 
+      {
+        m_destPolys.Capacity = m_polyNodes.ChildCount;
+        for (int i = 0; i < m_polyNodes.ChildCount; i++)
+        {
+          PolyNode node = m_polyNodes.Childs[i];
+          if (node.m_endtype == EndType.etClosedPolygon)
+            m_destPolys.Add(node.m_polygon);
+        }
+        return;
+      }
+
+      //see offset_triginometry3.svg in the documentation folder ...
+      if (MiterLimit > 2) m_miterLim = 2 / (MiterLimit * MiterLimit);
+      else m_miterLim = 0.5;
+
+      double y;
+      if (ArcTolerance <= 0.0) 
+        y = def_arc_tolerance;
+      else if (ArcTolerance > Math.Abs(delta) * def_arc_tolerance)
+        y = Math.Abs(delta) * def_arc_tolerance;
+      else 
+        y = ArcTolerance;
+      //see offset_triginometry2.svg in the documentation folder ...
+      double steps = Math.PI / Math.Acos(1 - y / Math.Abs(delta));
+      m_sin = Math.Sin(two_pi / steps);
+      m_cos = Math.Cos(two_pi / steps);
+      m_StepsPerRad = steps / two_pi;
+      if (delta < 0.0) m_sin = -m_sin;
+
+      m_destPolys.Capacity = m_polyNodes.ChildCount * 2;
+      for (int i = 0; i < m_polyNodes.ChildCount; i++)
+      {
+        PolyNode node = m_polyNodes.Childs[i];
+        m_srcPoly = node.m_polygon;
+
+        int len = m_srcPoly.Count;
+
+        if (len == 0 || (delta <= 0 && (len < 3 || 
+          node.m_endtype != EndType.etClosedPolygon)))
+            continue;
+
+        m_destPoly = new Path();
+
+        if (len == 1)
+        {
+          if (node.m_jointype == JoinType.jtRound)
+          {
+            double X = 1.0, Y = 0.0;
+            for (int j = 1; j <= steps; j++)
+            {
+              m_destPoly.Add(new IntPoint(
+                Round(m_srcPoly[0].X + X * delta),
+                Round(m_srcPoly[0].Y + Y * delta)));
+              double X2 = X;
+              X = X * m_cos - m_sin * Y;
+              Y = X2 * m_sin + Y * m_cos;
+            }
+          }
+          else
+          {
+            double X = -1.0, Y = -1.0;
+            for (int j = 0; j < 4; ++j)
+            {
+              m_destPoly.Add(new IntPoint(
+                Round(m_srcPoly[0].X + X * delta),
+                Round(m_srcPoly[0].Y + Y * delta)));
+              if (X < 0) X = 1;
+              else if (Y < 0) Y = 1;
+              else X = -1;
+            }
+          }
+          m_destPolys.Add(m_destPoly);
+          continue;
+        }
+
+        //build m_normals ...
+        m_normals.Clear();
+        m_normals.Capacity = len;
+        for (int j = 0; j < len - 1; j++)
+          m_normals.Add(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
+        if (node.m_endtype == EndType.etClosedLine || 
+          node.m_endtype == EndType.etClosedPolygon)
+          m_normals.Add(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
+        else
+          m_normals.Add(new DoublePoint(m_normals[len - 2]));
+
+        if (node.m_endtype == EndType.etClosedPolygon)
+        {
+          int k = len - 1;
+          for (int j = 0; j < len; j++)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+        }
+        else if (node.m_endtype == EndType.etClosedLine)
+        {
+          int k = len - 1;
+          for (int j = 0; j < len; j++)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+          m_destPoly = new Path();
+          //re-build m_normals ...
+          DoublePoint n = m_normals[len - 1];
+          for (int j = len - 1; j > 0; j--)
+            m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+          m_normals[0] = new DoublePoint(-n.X, -n.Y);
+          k = 0;
+          for (int j = len - 1; j >= 0; j--)
+            OffsetPoint(j, ref k, node.m_jointype);
+          m_destPolys.Add(m_destPoly);
+        }
+        else
+        {
+          int k = 0;
+          for (int j = 1; j < len - 1; ++j)
+            OffsetPoint(j, ref k, node.m_jointype);
+
+          IntPoint pt1;
+          if (node.m_endtype == EndType.etOpenButt)
+          {
+            int j = len - 1;
+            pt1 = new IntPoint((cInt)Round(m_srcPoly[j].X + m_normals[j].X *
+              delta), (cInt)Round(m_srcPoly[j].Y + m_normals[j].Y * delta));
+            m_destPoly.Add(pt1);
+            pt1 = new IntPoint((cInt)Round(m_srcPoly[j].X - m_normals[j].X *
+              delta), (cInt)Round(m_srcPoly[j].Y - m_normals[j].Y * delta));
+            m_destPoly.Add(pt1);
+          }
+          else
+          {
+            int j = len - 1;
+            k = len - 2;
+            m_sinA = 0;
+            m_normals[j] = new DoublePoint(-m_normals[j].X, -m_normals[j].Y);
+            if (node.m_endtype == EndType.etOpenSquare)
+              DoSquare(j, k);
+            else
+              DoRound(j, k);
+          }
+
+          //re-build m_normals ...
+          for (int j = len - 1; j > 0; j--)
+            m_normals[j] = new DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+
+          m_normals[0] = new DoublePoint(-m_normals[1].X, -m_normals[1].Y);
+
+          k = len - 1;
+          for (int j = k - 1; j > 0; --j)
+            OffsetPoint(j, ref k, node.m_jointype);
+
+          if (node.m_endtype == EndType.etOpenButt)
+          {
+            pt1 = new IntPoint((cInt)Round(m_srcPoly[0].X - m_normals[0].X * delta),
+              (cInt)Round(m_srcPoly[0].Y - m_normals[0].Y * delta));
+            m_destPoly.Add(pt1);
+            pt1 = new IntPoint((cInt)Round(m_srcPoly[0].X + m_normals[0].X * delta),
+              (cInt)Round(m_srcPoly[0].Y + m_normals[0].Y * delta));
+            m_destPoly.Add(pt1);
+          }
+          else
+          {
+            k = 1;
+            m_sinA = 0;
+            if (node.m_endtype == EndType.etOpenSquare)
+              DoSquare(0, 1);
+            else
+              DoRound(0, 1);
+          }
+          m_destPolys.Add(m_destPoly);
+        }
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void Execute(ref Paths solution, double delta)
+    {
+      solution.Clear();
+      FixOrientations();
+      DoOffset(delta);
+      //now clean up 'corners' ...
+      Clipper clpr = new Clipper();
+      clpr.AddPaths(m_destPolys, PolyType.ptSubject, true);
+      if (delta > 0)
+      {
+        clpr.Execute(ClipType.ctUnion, solution,
+          PolyFillType.pftPositive, PolyFillType.pftPositive);
+      }
+      else
+      {
+        IntRect r = Clipper.GetBounds(m_destPolys);
+        Path outer = new Path(4);
+
+        outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.top - 10));
+        outer.Add(new IntPoint(r.left - 10, r.top - 10));
+
+        clpr.AddPath(outer, PolyType.ptSubject, true);
+        clpr.ReverseSolution = true;
+        clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
+        if (solution.Count > 0) solution.RemoveAt(0);
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    public void Execute(ref PolyTree solution, double delta)
+    {
+      solution.Clear();
+      FixOrientations();
+      DoOffset(delta);
+
+      //now clean up 'corners' ...
+      Clipper clpr = new Clipper();
+      clpr.AddPaths(m_destPolys, PolyType.ptSubject, true);
+      if (delta > 0)
+      {
+        clpr.Execute(ClipType.ctUnion, solution,
+          PolyFillType.pftPositive, PolyFillType.pftPositive);
+      }
+      else
+      {
+        IntRect r = Clipper.GetBounds(m_destPolys);
+        Path outer = new Path(4);
+
+        outer.Add(new IntPoint(r.left - 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.bottom + 10));
+        outer.Add(new IntPoint(r.right + 10, r.top - 10));
+        outer.Add(new IntPoint(r.left - 10, r.top - 10));
+
+        clpr.AddPath(outer, PolyType.ptSubject, true);
+        clpr.ReverseSolution = true;
+        clpr.Execute(ClipType.ctUnion, solution, PolyFillType.pftNegative, PolyFillType.pftNegative);
+        //remove the outer PolyNode rectangle ...
+        if (solution.ChildCount == 1 && solution.Childs[0].ChildCount > 0)
+        {
+          PolyNode outerNode = solution.Childs[0];
+          solution.Childs.Capacity = outerNode.ChildCount;
+          solution.Childs[0] = outerNode.Childs[0];
+          solution.Childs[0].m_Parent = solution;
+          for (int i = 1; i < outerNode.ChildCount; i++)
+            solution.AddChild(outerNode.Childs[i]);
+        }
+        else
+          solution.Clear();
+      }
+    }
+    //------------------------------------------------------------------------------
+
+    void OffsetPoint(int j, ref int k, JoinType jointype)
+    {
+      //cross product ...
+      m_sinA = (m_normals[k].X * m_normals[j].Y - m_normals[j].X * m_normals[k].Y);
+
+      if (Math.Abs(m_sinA * m_delta) < 1.0) 
+      {
+        //dot product ...
+        double cosA = (m_normals[k].X * m_normals[j].X + m_normals[j].Y * m_normals[k].Y); 
+        if (cosA > 0) // angle ==> 0 degrees
+        {
+          m_destPoly.Add(new IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta),
+            Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta)));
+          return; 
+        }
+        //else angle ==> 180 degrees   
+      }
+      else if (m_sinA > 1.0) m_sinA = 1.0;
+      else if (m_sinA < -1.0) m_sinA = -1.0;
+      
+      if (m_sinA * m_delta < 0)
+      {
+        m_destPoly.Add(new IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta),
+          Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta)));
+        m_destPoly.Add(m_srcPoly[j]);
+        m_destPoly.Add(new IntPoint(Round(m_srcPoly[j].X + m_normals[j].X * m_delta),
+          Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta)));
+      }
+      else
+        switch (jointype)
+        {
+          case JoinType.jtMiter:
+            {
+              double r = 1 + (m_normals[j].X * m_normals[k].X +
+                m_normals[j].Y * m_normals[k].Y);
+              if (r >= m_miterLim) DoMiter(j, k, r); else DoSquare(j, k);
+              break;
+            }
+          case JoinType.jtSquare: DoSquare(j, k); break;
+          case JoinType.jtRound: DoRound(j, k); break;
+        }
+      k = j;
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoSquare(int j, int k)
+    {
+      double dx = Math.Tan(Math.Atan2(m_sinA,
+          m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y) / 4);
+      m_destPoly.Add(new IntPoint(
+          Round(m_srcPoly[j].X + m_delta * (m_normals[k].X - m_normals[k].Y * dx)),
+          Round(m_srcPoly[j].Y + m_delta * (m_normals[k].Y + m_normals[k].X * dx))));
+      m_destPoly.Add(new IntPoint(
+          Round(m_srcPoly[j].X + m_delta * (m_normals[j].X + m_normals[j].Y * dx)),
+          Round(m_srcPoly[j].Y + m_delta * (m_normals[j].Y - m_normals[j].X * dx))));
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoMiter(int j, int k, double r)
+    {
+      double q = m_delta / r;
+      m_destPoly.Add(new IntPoint(Round(m_srcPoly[j].X + (m_normals[k].X + m_normals[j].X) * q),
+          Round(m_srcPoly[j].Y + (m_normals[k].Y + m_normals[j].Y) * q)));
+    }
+    //------------------------------------------------------------------------------
+
+    internal void DoRound(int j, int k)
+    {
+      double a = Math.Atan2(m_sinA,
+      m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y);
+      int steps = Math.Max((int)Round(m_StepsPerRad * Math.Abs(a)),1);
+
+      double X = m_normals[k].X, Y = m_normals[k].Y, X2;
+      for (int i = 0; i < steps; ++i)
+      {
+        m_destPoly.Add(new IntPoint(
+            Round(m_srcPoly[j].X + X * m_delta),
+            Round(m_srcPoly[j].Y + Y * m_delta)));
+        X2 = X;
+        X = X * m_cos - m_sin * Y;
+        Y = X2 * m_sin + Y * m_cos;
+      }
+      m_destPoly.Add(new IntPoint(
+      Round(m_srcPoly[j].X + m_normals[j].X * m_delta),
+      Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta)));
+    }
+    //------------------------------------------------------------------------------
+  }
+
+  class ClipperException : Exception
+  {
+      public ClipperException(string description) : base(description){}
+  }
+  //------------------------------------------------------------------------------
+
+} //end ClipperLib namespace
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..fff10e792c95b3fb485d40252d0f104f3a7da069
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/ClipperLib/clipper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1139f30c04130724d998e1bae48d15c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Dark.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Dark.meta
new file mode 100644
index 0000000000000000000000000000000000000000..460509806a6c86244181c02240f9ddf1a5aa52fa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Dark.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 29376bbf08d892f46b253107863393d6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Light.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Light.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7c0f99126e336531626ea552bb640b6273956ac6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Light.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 56b6316a880c556419c7dff52b1751e6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Selected.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Selected.meta
new file mode 100644
index 0000000000000000000000000000000000000000..956237c2efd68f9489dae65e5a766687749a6ebc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/Icons/Selected.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ddadd2007ee717343adbaf3cab44f7f9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs
new file mode 100644
index 0000000000000000000000000000000000000000..92e038cc5ce2216c64c471459a54860a7618f5cd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs
@@ -0,0 +1,57 @@
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Layout
+{
+	internal class DropdownMenu : VisualElement
+	{
+		public class DropdownMenuFactory : UxmlFactory<DropdownMenu, DropdownMenuUxmlTraits> {}
+		public class DropdownMenuUxmlTraits : UxmlTraits {}
+
+		/*
+		private ButtonGroup m_ButtonGroup;
+
+		public DropdownMenu()
+		{
+			RegisterCallback<FocusOutEvent>(OnFocusOut, Capture.NoCapture);
+			RegisterCallback<MouseLeaveEvent>(OnMouseLeaveEvent);
+		}
+
+		public void InitialiseWithButtonGroup(ButtonGroup buttonGroup)
+		{
+			if (m_ButtonGroup == buttonGroup)
+				return;
+
+			m_ButtonGroup = buttonGroup;
+			var buttonGroupLocalPosition = parent.WorldToLocal(new Vector2(buttonGroup.worldBound.x, buttonGroup.worldBound.y));
+			style.positionType = PositionType.Absolute;
+			style.positionLeft = buttonGroupLocalPosition.x;
+			style.positionTop = buttonGroupLocalPosition.y;
+			style.flexDirection = buttonGroup.isHorizontal ? FlexDirection.Row : FlexDirection.Column;
+			foreach (var element in buttonGroup.elements)
+				Add(element);
+		}
+
+		private void OnMouseLeaveEvent(MouseLeaveEvent evt)
+		{
+			Close();
+		}
+
+		private void OnFocusOut(FocusOutEvent evt)
+		{
+			Close();
+		}
+
+		private void Close()
+		{
+			foreach (var element in contentContainer.Children())
+				m_ButtonGroup.elements.Add(element);
+			this.contentContainer.Clear();
+
+			style.width = 0;
+			style.height = 0;
+			m_ButtonGroup = null;
+		}
+		*/
+	}
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..53e673c9c6f6d6de4b57d037b913670d3593287d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/LayoutOverlay/DropdownMenu.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b245eff55d115544b9cc52444a1b8ca5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/ISpriteMeshView.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/ISpriteMeshView.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..89f4952e3a9a498948f0f05af0e5ec164f2da4fa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/ISpriteMeshView.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 015d7144666ec57449ae83559d3e26c6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/RectSelectionTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/RectSelectionTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..bbe88c8b06d15638dd862d1a5c2e8679f9653311
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/IMGUI/RectSelectionTool.cs
@@ -0,0 +1,70 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class RectSelectionTool<T>
+    {
+        private int m_HashCode = "RectSelectionTool".GetHashCode();
+        private int m_ControlID = -1;
+        private bool m_Moved = false;
+        private RectSlider m_RectSlider = new RectSlider();
+        public int controlID { get { return m_ControlID; } }
+        public IRectSelector<T> rectSelector { get; set; }
+        public ICacheUndo cacheUndo { get; set; }
+        public Action onSelectionStart = () => {};
+        public Action onSelectionUpdate = () => {};
+        public Action onSelectionEnd = () => {};
+
+        public void OnGUI()
+        {
+            Debug.Assert(rectSelector != null);
+            Debug.Assert(cacheUndo != null);
+
+            m_ControlID = GUIUtility.GetControlID(m_HashCode, FocusType.Passive);
+
+            Event ev = Event.current;
+            EventType eventType = ev.GetTypeForControl(m_ControlID);
+
+            if (GUIUtility.hotControl == 0 && HandleUtility.nearestControl == m_ControlID &&
+                rectSelector.selection.Count > 0 && eventType == EventType.MouseDown && ev.button == 0 && !ev.alt)
+            {
+                m_Moved = false;
+                onSelectionStart();
+            }
+
+            if (m_Moved && GUIUtility.hotControl == m_ControlID && eventType == EventType.MouseUp && ev.button == 0)
+            {
+                cacheUndo.BeginUndoOperation(TextContent.selection);
+                rectSelector.selection.EndSelection(true);
+                onSelectionEnd();
+            }
+
+            EditorGUI.BeginChangeCheck();
+
+            rectSelector.rect = m_RectSlider.Do(m_ControlID);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                if(!m_Moved)
+                {
+                    cacheUndo.BeginUndoOperation(TextContent.selection);
+
+                    if(!ev.shift)
+                        rectSelector.selection.Clear();
+                        
+                    m_Moved = true;
+                }
+                
+                rectSelector.selection.BeginSelection();
+                rectSelector.Select();
+                onSelectionUpdate();
+            }
+
+            if (eventType == EventType.Repaint && GUIUtility.hotControl == m_ControlID)
+            {
+                DrawingUtility.DrawRect(rectSelector.rect, Vector3.zero, Quaternion.identity, new Color(0f, 1f, 1f, 1f), 0.05f, 0.8f);
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64.meta
new file mode 100644
index 0000000000000000000000000000000000000000..68d03e3cd74390b174ec2a64a27af936609b6ecb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3d7adf78a0bd60848be2470847fbf8ea
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64/BoundedBiharmonicWeightsModule.so.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64/BoundedBiharmonicWeightsModule.so.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b1abd63543cd46ca59d693a9f71660b339a7aad5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x64/BoundedBiharmonicWeightsModule.so.meta
@@ -0,0 +1,83 @@
+fileFormatVersion: 2
+guid: 35869f4d0e1d03e4ebffcc461c55773f
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      '': Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 0
+        Exclude Linux: 1
+        Exclude Linux64: 1
+        Exclude LinuxUniversal: 1
+        Exclude OSXUniversal: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: Linux
+  - first:
+      Facebook: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Facebook: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Linux
+    second:
+      enabled: 0
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x86_64.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x86_64.meta
new file mode 100644
index 0000000000000000000000000000000000000000..88a3d10e7d263355d3eba17f05a00a7c00ce5264
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Lib/x86_64.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5335ae1a0cfbc2c41903fdf8d489fcc7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshPreviewTool/IMeshPreviewBehaviour.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshPreviewTool/IMeshPreviewBehaviour.cs
new file mode 100644
index 0000000000000000000000000000000000000000..fbd94926819a3e99d9eec4712390e26acfe775df
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/MeshPreviewTool/IMeshPreviewBehaviour.cs
@@ -0,0 +1,13 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IMeshPreviewBehaviour
+    {
+        float GetWeightMapOpacity(SpriteCache sprite);
+        bool DrawWireframe(SpriteCache sprite);
+        bool Overlay(SpriteCache sprite);
+        bool OverlayWireframe(SpriteCache sprite);
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/ModuleUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/ModuleUtility.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..bdbb89abbf34fa44e9a6be70d4a57a081c546572
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/ModuleUtility.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa2a7a8ee6a464dd9ae636e73111beb6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator.meta
new file mode 100644
index 0000000000000000000000000000000000000000..6681e021e0113b0908d8aad7a4f33cf4c722e47c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2a8a39f0e276884449c4610fee697330
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator/IOutlineGenerator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator/IOutlineGenerator.cs
new file mode 100644
index 0000000000000000000000000000000000000000..2873b206c55f002f48571097e2f7b5b9e0fbe660
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/OutlineGenerator/IOutlineGenerator.cs
@@ -0,0 +1,10 @@
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IOutlineGenerator
+    {
+        void GenerateOutline(ITextureDataProvider textureDataProvider, Rect rect, float detail, byte alphaTolerance, bool holeDetection, out Vector2[][] paths);
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection.meta
new file mode 100644
index 0000000000000000000000000000000000000000..29ec18c16b60e38cca02193b6d07374ced355bd5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0a68d56945b68344ea2f451f0e9f14b4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs
new file mode 100644
index 0000000000000000000000000000000000000000..ed01a39d4a553ee31947051c7692f542e15f302c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs
@@ -0,0 +1,21 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal class BoneSelection : SerializableSelection<BoneCache>, IBoneSelection
+    {
+        protected override BoneCache GetInvalidElement() { return null; }
+
+        public BoneCache root
+        {
+            get { return activeElement.FindRoot<BoneCache>(elements); }
+        }
+
+        public BoneCache[] roots
+        {
+            get { return elements.FindRoots<BoneCache>(); }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..70fabd73e1a50181af22a6e66c7122bc7b4913e9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/BoneSelection.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 10db00a3c51d23d4ab8a68837ffa21fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/IBoneSelection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/IBoneSelection.cs
new file mode 100644
index 0000000000000000000000000000000000000000..56cc12d7ba350ff4897ba6d9f017cec57e1b1000
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selection/IBoneSelection.cs
@@ -0,0 +1,7 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IBoneSelection : ITransformSelection<BoneCache> {}
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3c7b29e14a19f82d1ab4336f26c5efd80b9a0b99
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs
@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.U2D.Layout;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SelectionTool : BaseTool
+    {
+        private bool m_ForceSelectedToSpriteEditor = false;
+
+        public event Func<bool> CanSelect = () => true;
+        private List<SpriteCache> m_Sprites;
+        public ISpriteEditor spriteEditor { get; set; }
+        private SpriteCache selectedSprite
+        {
+            get { return skinningCache.selectedSprite; }
+            set
+            {
+                if (selectedSprite != value)
+                {
+                    skinningCache.vertexSelection.Clear();
+
+                    if (skinningCache.mode == SkinningMode.SpriteSheet)
+                    {
+                        skinningCache.skeletonSelection.Clear();
+                        skinningCache.events.boneSelectionChanged.Invoke();
+                    }
+
+                    skinningCache.selectedSprite = value;
+                    SetToSpriteEditor();
+                    skinningCache.events.selectedSpriteChanged.Invoke(value);
+                }
+            }
+        }
+
+        private string selectedSpriteAssetID
+        {
+            get
+            {
+                var sprite = Selection.activeObject as Sprite;
+
+                if (sprite != null)
+                    return sprite.GetSpriteID().ToString();
+
+                return "";
+            }
+        }
+
+        protected override void OnAfterDeserialize()
+        {
+            m_ForceSelectedToSpriteEditor = true;
+        }
+
+        public override void Initialize(LayoutOverlay layoutOverlay)
+        {
+            m_Sprites = new List<SpriteCache>(skinningCache.GetSprites());
+            SetFromSpriteEditor();
+        }
+
+        protected override void OnActivate()
+        {
+            SetToSpriteEditor();
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSpriteSelectionChange);
+            Selection.selectionChanged -= OnSelectionChanged;
+            Selection.selectionChanged += OnSelectionChanged;
+        }
+
+        protected override void OnDeactivate()
+        {
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSpriteSelectionChange);
+            Selection.selectionChanged -= OnSelectionChanged;
+        }
+
+        private void OnSpriteSelectionChange(SpriteCache sprite)
+        {
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSpriteSelectionChange);
+            selectedSprite = sprite;
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSpriteSelectionChange);
+        }
+
+        private void OnSelectionChanged()
+        {
+            if (m_ForceSelectedToSpriteEditor)
+            {
+                SetToSpriteEditor();
+                m_ForceSelectedToSpriteEditor = false;
+            }
+            else
+            {
+                using (skinningCache.UndoScope(TextContent.selectionChange))
+                {
+                    SetFromSpriteEditor();
+                }
+            }
+        }
+
+        private void SetFromSpriteEditor()
+        {
+            if (selectedSprite == null)
+                selectedSprite = skinningCache.GetSprite(selectedSpriteAssetID);
+            spriteEditor.RequestRepaint();
+        }
+
+        private void SetToSpriteEditor()
+        {
+            var id = "";
+
+            if (selectedSprite != null)
+                id = selectedSprite.id;
+
+            spriteEditor.selectedSpriteRect = new SpriteRect() { spriteID = new GUID(id) };
+        }
+
+        protected override void OnGUI()
+        {
+            HandleSpriteSelection();
+        }
+
+        private void HandleSpriteSelection()
+        {
+            Debug.Assert(Event.current != null);
+
+            if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && GUIUtility.hotControl == 0 &&
+                !Event.current.alt && Event.current.clickCount == 2 && CanSelect())
+            {
+                var mousePosition = Handles.inverseMatrix.MultiplyPoint(Event.current.mousePosition);
+                var newSelected = TrySelect(mousePosition);
+                if (selectedSprite != newSelected)
+                {
+                    using (skinningCache.UndoScope(TextContent.selectionChange))
+                    {
+                        selectedSprite = newSelected;
+                    }
+                    Event.current.Use();
+                    Event.current.clickCount = 0;
+                }
+            }
+        }
+
+        private SpriteCache TrySelect(Vector2 mousePosition)
+        {
+            m_Sprites.Remove(selectedSprite);
+
+            if (selectedSprite != null)
+                m_Sprites.Add(selectedSprite);
+
+            var currentSelectedIndex = m_Sprites.FindIndex(x => x == selectedSprite) + 1;
+            var notVisiblePart = skinningCache.hasCharacter && skinningCache.mode == SkinningMode.Character
+                ? skinningCache.character.parts.Where(x => !x.isVisible).Select(x => x.sprite) : new SpriteCache[0];
+            for (int index = 0; index < m_Sprites.Count; ++index)
+            {
+                var sprite = m_Sprites[(currentSelectedIndex + index) % m_Sprites.Count];
+                var meshPreview = sprite.GetMeshPreview();
+                if (notVisiblePart.Contains(sprite))
+                    continue;
+
+                Debug.Assert(meshPreview != null);
+
+                var spritePosition = sprite.GetLocalToWorldMatrixFromMode().MultiplyPoint3x4(Vector3.zero);
+                var ray = new Ray((Vector3)mousePosition - spritePosition + Vector3.back, Vector3.forward);
+                var bounds = meshPreview.mesh.bounds;
+
+                if (sprite.GetMesh().indices.Count >= 3)
+                {
+                    if (bounds.IntersectRay(ray))
+                    {
+                        var mesh = sprite.GetMesh();
+
+                        Debug.Assert(mesh != null);
+
+                        var indices = mesh.indices;
+                        for (var i = 0; i < indices.Count; i += 3)
+                        {
+                            var p1 = meshPreview.vertices[indices[i]];
+                            var p2 = meshPreview.vertices[indices[i + 1]];
+                            var p3 = meshPreview.vertices[indices[i + 2]];
+
+                            if (MathUtility.Intersect(p1, p2, p3, ray))
+                                return sprite;
+                        }
+                    }
+                }
+                else
+                {
+                    if (meshPreview.defaultMesh.bounds.IntersectRay(ray))
+                    {
+                        return sprite;
+                    }
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..f0bebf7064ee14f56f428b856311a511238e730f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SelectionTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5260ebe2b8ba2724eb92daea93bddf3c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selectors.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selectors.meta
new file mode 100644
index 0000000000000000000000000000000000000000..ca668bcf6e914ca88c31efbd07f07648b5940a9b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Selectors.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 37f3979cbd2490a4c87552d59e76b1f6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs
new file mode 100644
index 0000000000000000000000000000000000000000..969e54dc266702dbc3a99697b017efcbe2856723
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal class SerializableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ISerializationCallbackReceiver
+    {
+        [SerializeField]
+        private List<TKey> m_Keys;
+        [SerializeField]
+        private List<TValue> m_Values;
+        private Dictionary<TKey, TValue> m_Dictionary = new Dictionary<TKey, TValue>();
+
+        public TValue this[TKey key]
+        {
+            get { return m_Dictionary[key]; }
+            set { m_Dictionary[key] = value; }
+        }
+
+        public TKey this[TValue value]
+        {
+            get
+            {
+                m_Keys = new List<TKey>(m_Dictionary.Keys);
+                m_Values = new List<TValue>(m_Dictionary.Values);
+                var index = m_Values.FindIndex(x => x.Equals(value));
+                if (index < 0)
+                    throw new KeyNotFoundException();
+                return m_Keys[index];
+            }
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get { return m_Dictionary.Keys; }
+        }
+
+        public ICollection<TValue> Values
+        {
+            get { return m_Dictionary.Values; }
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            m_Dictionary.Add(key, value);
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            return m_Dictionary.ContainsKey(key);
+        }
+
+        public bool Remove(TKey key)
+        {
+            return m_Dictionary.Remove(key);
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return m_Dictionary.TryGetValue(key, out value);
+        }
+
+        public void Clear()
+        {
+            m_Dictionary.Clear();
+        }
+
+        public int Count
+        {
+            get { return m_Dictionary.Count; }
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
+        {
+            get { return (m_Dictionary as ICollection<KeyValuePair<TKey, TValue>>).IsReadOnly; }
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
+        {
+            (m_Dictionary as ICollection<KeyValuePair<TKey, TValue>>).Add(item);
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
+        {
+            return (m_Dictionary as ICollection<KeyValuePair<TKey, TValue>>).Contains(item);
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            (m_Dictionary as ICollection<KeyValuePair<TKey, TValue>>).CopyTo(array, arrayIndex);
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
+        {
+            return (m_Dictionary as ICollection<KeyValuePair<TKey, TValue>>).Remove(item);
+        }
+
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+        {
+            return (m_Dictionary as IEnumerable<KeyValuePair<TKey, TValue>>).GetEnumerator();
+        }
+
+        public IEnumerator GetEnumerator()
+        {
+            return m_Dictionary.GetEnumerator();
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+            m_Keys = new List<TKey>(m_Dictionary.Keys);
+            m_Values = new List<TValue>(m_Dictionary.Values);
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            Debug.Assert(m_Keys.Count == m_Values.Count);
+            Clear();
+            for (var i = 0; i < m_Keys.Count; ++i)
+                Add(m_Keys[i], m_Values[i]);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c8ea129049b5dc39476d37e20fd18a08b1e52c70
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SerializableDictionary.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e96f8a2db4cc7d48a77700beddf5d34
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool.meta
new file mode 100644
index 0000000000000000000000000000000000000000..4926331d63300c016db8c46bb51ba41188e72d72
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 08f15e56bdceb584f8b33ce6d6e22aa7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs
new file mode 100644
index 0000000000000000000000000000000000000000..9bfa0f04e01e595a8bf0a26c1b534d1605e7a1ee
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs
@@ -0,0 +1,68 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SkeletonToolWrapper : BaseTool
+    {
+        private SkeletonTool m_SkeletonTool;
+        private SkeletonMode m_Mode;
+
+        public SkeletonTool skeletonTool
+        {
+            get { return m_SkeletonTool; }
+            set { m_SkeletonTool = value; }
+        }
+
+        public SkeletonMode mode
+        {
+            get { return m_Mode; }
+            set { m_Mode = value; }
+        }
+
+        public bool editBindPose { get; set; }
+
+        public override int defaultControlID
+        {
+            get
+            {
+                Debug.Assert(skeletonTool != null);
+
+                return skeletonTool.defaultControlID;
+            }
+        }
+
+        protected override void OnActivate()
+        {
+            Debug.Assert(skeletonTool != null);
+            skeletonTool.enableBoneInspector = true;
+            skeletonTool.Activate();
+        }
+
+        protected override void OnDeactivate()
+        {
+            skeletonTool.enableBoneInspector = false;
+            skeletonTool.Deactivate();
+        }
+
+        private SkeletonMode OverrideMode()
+        {
+            var modeOverride = mode;
+
+            //Disable SkeletonManipulation if character exists and we are in SpriteSheet mode
+            if (skinningCache.mode == SkinningMode.SpriteSheet && skinningCache.hasCharacter && editBindPose)
+                modeOverride = SkeletonMode.Selection;
+
+            return modeOverride;
+        }
+
+        protected override void OnGUI()
+        {
+            Debug.Assert(skeletonTool != null);
+
+            skeletonTool.mode = OverrideMode();
+            skeletonTool.editBindPose = editBindPose;
+            skeletonTool.DoGUI();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..f5fe403bade64b86864718dd42f2ccb0cdea1d39
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkeletonTool/SkeletonToolWrapper.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d7d16e2d9869a84190616f30b11be2d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache.meta
new file mode 100644
index 0000000000000000000000000000000000000000..a484909536b090b0f31a84141e21f537f8e5c545
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 181aae7e64f90f940a2588cc2b4cbaf7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..e3d163706d776ea7d081233db2f5cca59b3ae689
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs
@@ -0,0 +1,332 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal struct Pose
+    {
+        public Vector3 position;
+        public Quaternion rotation;
+        public Matrix4x4 matrix
+        {
+            get { return Matrix4x4.TRS(position, rotation, Vector3.one); }
+        }
+
+        public static Pose Create(Vector3 p, Quaternion r)
+        {
+            var pose = new Pose()
+            {
+                position = p,
+                rotation = r
+            };
+
+            return pose;
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is Pose && this == (Pose)other;
+        }
+
+        public override int GetHashCode()
+        {
+            return position.GetHashCode() ^ rotation.GetHashCode();
+        }
+
+        public static bool operator==(Pose p1, Pose p2)
+        {
+            return p1.position == p2.position && p1.rotation == p2.rotation;
+        }
+
+        public static bool operator!=(Pose p1, Pose p2)
+        {
+            return !(p1 == p2);
+        }
+    }
+
+    [Serializable]
+    internal struct BonePose
+    {
+        public Pose pose;
+        public float length;
+        public static BonePose Create(Pose p, float l)
+        {
+            var pose = new BonePose()
+            {
+                pose = p,
+                length = l
+            };
+
+            return pose;
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is BonePose && this == (BonePose)other;
+        }
+
+        public override int GetHashCode()
+        {
+            return pose.GetHashCode() ^ length.GetHashCode();
+        }
+
+        public static bool operator==(BonePose p1, BonePose p2)
+        {
+            return p1.pose == p2.pose && p1.length == p2.length;
+        }
+
+        public static bool operator!=(BonePose p1, BonePose p2)
+        {
+            return !(p1 == p2);
+        }
+    }
+
+    internal class BoneCache : TransformCache
+    {
+        [SerializeField]
+        Color m_BindPoseColor;
+        [SerializeField]
+        private Pose m_BindPose;
+        [SerializeField]
+        private BonePose m_DefaultPose;
+        [SerializeField]
+        private BoneCache m_ChainedChild;
+        [SerializeField]
+        private float m_Depth;
+        [SerializeField]
+        private float m_LocalLength = 1f;
+        [SerializeField]
+        private bool m_IsVisible = true;
+
+        public bool NotInDefaultPose()
+        {
+            return localPosition != m_DefaultPose.pose.position
+                   || localRotation != m_DefaultPose.pose.rotation
+                   || localLength != m_DefaultPose.length;
+        }
+
+        public bool isVisible
+        {
+            get { return m_IsVisible; }
+            set { m_IsVisible = value; }
+        }
+
+        public Color bindPoseColor
+        {
+            get { return m_BindPoseColor; }
+            set { m_BindPoseColor = value; }
+        }
+
+        public virtual BoneCache parentBone
+        {
+            get { return parent as BoneCache; }
+        }
+
+        public SkeletonCache skeleton
+        {
+            get
+            {
+                var skeleton = parent as SkeletonCache;
+
+                if (skeleton != null)
+                    return skeleton;
+
+                if (parentBone != null)
+                    return parentBone.skeleton;
+
+                return null;
+            }
+        }
+
+        public virtual BoneCache chainedChild
+        {
+            get
+            {
+                if (m_ChainedChild != null && m_ChainedChild.parentBone == this)
+                    return m_ChainedChild;
+
+                return null;
+            }
+            set
+            {
+                if (m_ChainedChild != value)
+                {
+                    if (value == null || value.parentBone == this)
+                    {
+                        m_ChainedChild = value;
+                        if(m_ChainedChild != null)
+                            OrientToChainedChild(false);
+                    }
+                }
+            }
+        }
+
+        public Vector3 localEndPosition
+        {
+            get { return Vector3.right * localLength; }
+        }
+
+        public Vector3 endPosition
+        {
+            get { return localToWorldMatrix.MultiplyPoint3x4(localEndPosition); }
+            set
+            {
+                if (chainedChild == null)
+                {
+                    var direction = value - position;
+                    right = direction;
+                    length = direction.magnitude;
+                }
+            }
+        }
+
+        public BonePose localPose
+        {
+            get { return BonePose.Create(Pose.Create(localPosition, localRotation), localLength); }
+            set
+            {
+                localPosition = value.pose.position;
+                localRotation = value.pose.rotation;
+                localLength = value.length;
+            }
+        }
+
+        public BonePose worldPose
+        {
+            get { return BonePose.Create(Pose.Create(position, rotation), length); }
+            set
+            {
+                position = value.pose.position;
+                rotation = value.pose.rotation;
+                length = value.length;
+            }
+        }
+
+        public Pose bindPose
+        {
+            get { return m_BindPose; }
+            set { m_BindPose = value; }
+        }
+
+        public float depth
+        {
+            get { return m_Depth; }
+            set { m_Depth = value; }
+        }
+        public float localLength
+        {
+            get { return m_LocalLength; }
+            set { m_LocalLength = Mathf.Max(0f, value); }
+        }
+
+        public float length
+        {
+            get { return localToWorldMatrix.MultiplyVector(localEndPosition).magnitude; }
+            set { m_LocalLength = worldToLocalMatrix.MultiplyVector(right * Mathf.Max(0f, value)).magnitude; }
+        }
+
+        internal Pose[] GetChildrenWoldPose()
+        {
+            return Array.ConvertAll(children, c => Pose.Create(c.position, c.rotation));
+        }
+
+        internal void SetChildrenWorldPose(Pose[] worldPose)
+        {
+            var childrenArray = children;
+
+            Debug.Assert(childrenArray.Length == worldPose.Length);
+
+            for (var i = 0; i < childrenArray.Length; ++i)
+            {
+                var child = childrenArray[i];
+                var pose= worldPose[i];
+
+                child.position = pose.position;
+                child.rotation = pose.rotation;
+            }
+        }
+
+        internal override void OnDestroy()
+        {
+            base.OnDestroy();
+            m_ChainedChild = null;
+        }
+
+        new public void SetParent(TransformCache newParent)
+        {
+            SetParent(newParent, true);
+        }
+
+        new public void SetParent(TransformCache newParent, bool worldPositionStays)
+        {
+            if (parentBone != null && parentBone.chainedChild == this)
+                parentBone.chainedChild = null;
+
+            base.SetParent(newParent, worldPositionStays);
+
+            if (parentBone != null && parentBone.chainedChild == null && (parentBone.endPosition - position).sqrMagnitude < 0.001f)
+                parentBone.chainedChild = this;
+        }
+
+        public void OrientToChainedChild(bool freezeChildren)
+        {
+            Debug.Assert(chainedChild != null);
+
+            var childPosition = chainedChild.position;
+            var childRotation = chainedChild.rotation;
+
+            Pose[] childrenWorldPose = null;
+
+            if (freezeChildren)
+                childrenWorldPose = GetChildrenWoldPose();
+
+            right = childPosition - position;
+
+            if (freezeChildren)
+            {
+                SetChildrenWorldPose(childrenWorldPose);
+            }
+            else
+            {
+                chainedChild.position = childPosition;
+                chainedChild.rotation = childRotation;
+            }
+
+            length = (childPosition - position).magnitude;
+        }
+
+        public void SetDefaultPose()
+        {
+            m_DefaultPose = localPose;
+
+            if (IsUnscaled())
+                m_BindPose = worldPose.pose;
+            else
+                throw new Exception("BindPose cannot be set under global scale");
+        }
+
+        public void RestoreDefaultPose()
+        {
+            localPose = m_DefaultPose;
+        }
+
+        private bool IsUnscaled()
+        {
+            var currentTransform = this as TransformCache;
+
+            while (currentTransform != null)
+            {
+                var scale = currentTransform.localScale;
+                var isUnscaled = Mathf.Approximately(scale.x, 1f) && Mathf.Approximately(scale.y, 1f) && Mathf.Approximately(scale.z, 1f);
+
+                if (!isUnscaled)
+                    return false;
+
+                currentTransform = currentTransform.parent;
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..49fd65bc8cf59e25d1b6b5357fea931426d16b77
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 262d646365ba9344aa9e63c3d60c4522
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..691c534e3a3242fad0c301772928043954f2afb2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class BoneCacheExtensions
+    {
+        public static BoneCache[] ToCharacterIfNeeded(this BoneCache[] bones)
+        {
+            return Array.ConvertAll(bones, b => ToCharacterIfNeeded(b));
+        }
+
+        public static BoneCache[] ToSpriteSheetIfNeeded(this BoneCache[] bones)
+        {
+            return Array.ConvertAll(bones, b => ToSpriteSheetIfNeeded(b));
+        }
+
+        public static BoneCache ToCharacterIfNeeded(this BoneCache bone)
+        {
+            if (bone == null)
+                return null;
+
+            var skinningCache = bone.skinningCache;
+
+            if (skinningCache.hasCharacter)
+            {
+                if (bone.skeleton != skinningCache.character.skeleton)
+                {
+                    var selectedSprite = skinningCache.selectedSprite;
+
+                    if (selectedSprite == null)
+                        return null;
+
+                    var skeleton = selectedSprite.GetSkeleton();
+                    var characterPart = selectedSprite.GetCharacterPart();
+
+                    Debug.Assert(skeleton != null);
+                    Debug.Assert(characterPart != null);
+                    Debug.Assert(bone.skeleton == skeleton);
+                    Debug.Assert(skeleton.BoneCount == characterPart.BoneCount);
+
+                    var index = skeleton.IndexOf(bone);
+
+                    if (index == -1)
+                        bone = null;
+                    else
+                        bone = characterPart.GetBone(index);
+                }
+            }
+
+            return bone;
+        }
+
+        public static BoneCache ToSpriteSheetIfNeeded(this BoneCache bone)
+        {
+            if (bone == null)
+                return null;
+
+            var skinningCache = bone.skinningCache;
+
+            if (skinningCache.hasCharacter && skinningCache.mode == SkinningMode.SpriteSheet)
+            {
+                var selectedSprite = skinningCache.selectedSprite;
+
+                if (selectedSprite == null)
+                    return null;
+
+                var characterSkeleton = skinningCache.character.skeleton;
+
+                Debug.Assert(bone.skeleton == characterSkeleton);
+
+                var skeleton = selectedSprite.GetSkeleton();
+                var characterPart = selectedSprite.GetCharacterPart();
+
+                Debug.Assert(skeleton != null);
+                Debug.Assert(characterPart != null);
+                Debug.Assert(skeleton.BoneCount == characterPart.BoneCount);
+
+                var index = characterPart.IndexOf(bone);
+
+                if (index == -1)
+                    bone = null;
+                else
+                    bone = skeleton.GetBone(index);
+            }
+
+            return bone;
+        }
+
+        public static UnityEngine.U2D.SpriteBone ToSpriteBone(this BoneCache bone, Matrix4x4 rootTransform, int parentId)
+        {
+            var position = bone.localPosition;
+            var rotation = bone.localRotation;
+
+            if (parentId == -1)
+            {
+                rotation = bone.rotation;
+                position = rootTransform.inverse.MultiplyPoint3x4(bone.position);
+            }
+
+            return new UnityEngine.U2D.SpriteBone()
+            {
+                name = bone.name,
+                position = new Vector3(position.x, position.y, bone.depth),
+                rotation = rotation,
+                length = bone.localLength,
+                parentId = parentId
+            };
+        }
+
+        public static UnityEngine.U2D.SpriteBone[] ToSpriteBone(this BoneCache[] bones, Matrix4x4 rootTransform)
+        {
+            var spriteBones = new List<UnityEngine.U2D.SpriteBone>();
+
+            foreach (var bone in bones)
+            {
+                var parentId = -1;
+
+                if (ArrayUtility.Contains(bones, bone.parentBone))
+                    parentId = Array.IndexOf(bones, bone.parentBone);
+
+                spriteBones.Add(bone.ToSpriteBone(rootTransform, parentId));
+            }
+
+            return spriteBones.ToArray();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..228ad6bf661d462f009b20ee49824d64b48e9170
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/BoneCacheExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d50b4f1248a256c4d96a6b0e9f346671
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d0d4713fc21d75a4f5921cfadbc9372a1b57dffc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class CharacterCache : SkinningObject, IEnumerable<CharacterPartCache>
+    {
+        [SerializeField]
+        private SkeletonCache m_Skeleton;
+        [SerializeField]
+        private List<CharacterPartCache> m_Parts = new List<CharacterPartCache>();
+        [SerializeField]
+        private Vector2Int m_Dimension;
+        [SerializeField]
+        private List<CharacterGroupCache> m_Groups = new List<CharacterGroupCache>();
+
+        public SkeletonCache skeleton
+        {
+            get { return m_Skeleton; }
+            set { m_Skeleton = value; }
+        }
+
+        public virtual CharacterPartCache[] parts
+        {
+            get { return m_Parts.ToArray(); }
+            set { m_Parts = new List<CharacterPartCache>(value); }
+        }
+
+        public virtual CharacterGroupCache[] groups
+        {
+            get { return m_Groups.ToArray(); }
+            set { m_Groups = new List<CharacterGroupCache>(value); }
+        }
+
+        public Vector2Int dimension
+        {
+            get { return m_Dimension; }
+            set { m_Dimension = value; }
+        }
+
+        public IEnumerator<CharacterPartCache> GetEnumerator()
+        {
+            return ((IEnumerable<CharacterPartCache>)m_Parts).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<CharacterPartCache>)m_Parts).GetEnumerator();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..1abde16ef1ff55d4344cf1acb56438777e477559
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7fcfe3c97703ff145afae98c5b358e95
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..62bde6537f8a2fcd61e4f7a9d1dfe6f780bc6b8d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal class CharacterGroupCache : SkinningObject, ICharacterOrder
+    {
+        [SerializeField]
+        public int parentGroup;
+        [SerializeField]
+        private bool m_IsVisible = true;
+        [SerializeField]
+        private int m_Order = -1;
+
+        public bool isVisible
+        {
+            get => m_IsVisible;
+            set
+            {
+                m_IsVisible = value;
+                skinningCache.GroupVisibilityChanged(this);
+            }
+        }
+
+        public virtual int order
+        {
+            get => m_Order;
+            set => m_Order = value;
+        }
+    }
+
+    internal class CharacterPartCache : TransformCache, ICharacterOrder
+    {
+        [SerializeField]
+        private SpriteCache m_Sprite;
+        [SerializeField]
+        private List<BoneCache> m_Bones = new List<BoneCache>();
+        [SerializeField]
+        private bool m_IsVisible = true;
+        [SerializeField]
+        private int m_ParentGroup = -1;
+        [SerializeField]
+        private int m_Order = -1;
+
+        public virtual int order
+        {
+            get => m_Order;
+            set => m_Order = value;
+        }
+        
+        public int parentGroup
+        {
+            get { return m_ParentGroup; }
+            set { m_ParentGroup = value; }
+        }
+
+        public virtual bool isVisible
+        {
+            get { return m_IsVisible; }
+            set
+            {
+                m_IsVisible = value;
+                if (skinningCache != null)
+                    skinningCache.SpriteVisibilityChanged(this);
+            }
+        }
+
+        public int BoneCount { get { return m_Bones.Count; } }
+
+        public virtual SpriteCache sprite
+        {
+            get { return m_Sprite; }
+            set { m_Sprite = value; }
+        }
+
+        public BoneCache[] bones
+        {
+            get { return m_Bones.ToArray(); }
+            set { m_Bones = new List<BoneCache>(value); }
+        }
+
+        public BoneCache GetBone(int index)
+        {
+            return m_Bones[index];
+        }
+
+        public int IndexOf(BoneCache bone)
+        {
+            return m_Bones.IndexOf(bone);
+        }
+
+        public bool Contains(BoneCache bone)
+        {
+            return m_Bones.Contains(bone);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e928a3f1b641e5926e05f1501b1fbb8c11cb10a4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ad9a0e8a9171a24abf3f2b88bec2bfa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5d5393556fe7f67abb0574ad33f154e12badd622
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class CharacterPartCacheExtensions
+    {
+        public static void SyncSpriteSheetSkeleton(this CharacterPartCache characterPart)
+        {
+            var skinningCache = characterPart.skinningCache;
+            var character = skinningCache.character;
+            var characterSkeleton = character.skeleton;
+            var spriteSkeleton = characterPart.sprite.GetSkeleton();
+            var spriteSkeletonBones = spriteSkeleton.bones;
+            var characterPartBones = characterPart.bones;
+
+            if (spriteSkeletonBones.Length != characterPartBones.Length)
+                return;
+
+            for (var i = 0; i < characterPartBones.Length; ++i)
+            {
+                var spriteBone = spriteSkeletonBones[i];
+                var characterBone = characterPartBones[i];
+                var childWorldPose = spriteBone.GetChildrenWoldPose();
+
+                spriteBone.position = spriteSkeleton.localToWorldMatrix.MultiplyPoint3x4(
+                    characterPart.worldToLocalMatrix.MultiplyPoint3x4(characterBone.position));
+                spriteBone.rotation = characterBone.rotation;
+                spriteBone.length = characterBone.length;
+                spriteBone.name = characterBone.name;
+                spriteBone.depth = characterBone.depth;
+                spriteBone.bindPoseColor = characterBone.bindPoseColor;
+
+                spriteBone.SetChildrenWorldPose(childWorldPose);
+            }
+
+            if (characterSkeleton.isPosePreview)
+                spriteSkeleton.SetPosePreview();
+            else
+                spriteSkeleton.SetDefaultPose();
+        }
+
+        public static void DeassociateUnusedBones(this CharacterPartCache characterPart)
+        {
+            var skinningCache = characterPart.skinningCache;
+            var bones = characterPart.bones;
+
+            if (bones.Length == 0)
+                return;
+
+            Debug.Assert(characterPart.sprite != null);
+
+            var mesh = characterPart.sprite.GetMesh();
+
+            Debug.Assert(mesh != null);
+
+            var vertices = mesh.vertices;
+            var newBonesSet = new HashSet<BoneCache>();
+
+            foreach (var vertex in vertices)
+            {
+                var boneWeight = vertex.editableBoneWeight;
+
+                foreach (BoneWeightChannel channel in boneWeight)
+                    if (channel.enabled)
+                        newBonesSet.Add(bones[channel.boneIndex]);
+            }
+
+            bones = new List<BoneCache>(newBonesSet).ToArray();
+
+            characterPart.bones = bones;
+
+            characterPart.sprite.UpdateMesh(bones);
+
+            skinningCache.events.characterPartChanged.Invoke(characterPart);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b56e4616db5945da869128af29c026e7537d2e68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/CharacterPartCacheExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 08c6298ccaa77394ab7bed9478eb9a9a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..652c49a56c9420fce16def99bc829d2b79aa754d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs
@@ -0,0 +1,203 @@
+using System.Collections.Generic;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class MeshCache : SkinningObject, ISpriteMeshData
+    {
+        [SerializeField]
+        private SpriteCache m_Sprite;
+        [SerializeField]
+        private List<Vertex2D> m_Vertices = new List<Vertex2D>();
+        [SerializeField]
+        private List<int> m_Indices = new List<int>();
+        [SerializeField]
+        private List<Edge> m_Edges = new List<Edge>();
+        [SerializeField]
+        private List<BoneCache> m_Bones = new List<BoneCache>();
+        public ITextureDataProvider textureDataProvider { get; set; }
+
+        public SpriteCache sprite
+        {
+            get { return m_Sprite; }
+            set { m_Sprite = value; }
+        }
+
+        public List<Vertex2D> vertices
+        {
+            get { return m_Vertices; }
+            set { m_Vertices = value; }
+        }
+
+        public List<Vector3> vertexPositionOverride { get; set; }
+
+        public List<Edge> edges
+        {
+            get { return m_Edges; }
+            set { m_Edges = value; }
+        }
+
+        public List<int> indices
+        {
+            get { return m_Indices; }
+            set { m_Indices = value; }
+        }
+
+        public BoneCache[] bones
+        {
+            get { return m_Bones.ToArray(); }
+            set { SetBones(value); }
+        }
+
+        Rect ISpriteMeshData.frame
+        {
+            get { return sprite.textureRect; }
+            set {}
+        }
+
+        public int vertexCount
+        {
+            get { return m_Vertices.Count; }
+        }
+
+        public int boneCount
+        {
+            get { return m_Bones.Count; }
+        }
+
+        public Vector2 GetPosition(int index)
+        {
+            if (vertexPositionOverride != null)
+                return vertexPositionOverride[index];
+
+            return m_Vertices[index].position;
+        }
+
+        public void SetPosition(int index, Vector2 position)
+        {
+            if (vertexPositionOverride != null)
+                return;
+
+            m_Vertices[index].position = position;
+        }
+
+        public EditableBoneWeight GetWeight(int index)
+        {
+            return m_Vertices[index].editableBoneWeight;
+        }
+
+        public void SetWeight(int index, EditableBoneWeight weight)
+        {
+            m_Vertices[index].editableBoneWeight = weight;
+        }
+
+        public void AddVertex(Vector2 position, BoneWeight weight)
+        {
+            m_Vertices.Add(new Vertex2D(position, weight));
+        }
+
+        public void RemoveVertex(int index)
+        {
+            m_Vertices.RemoveAt(index);
+        }
+
+        SpriteBoneData ISpriteMeshData.GetBoneData(int index)
+        {
+            var worldToLocalMatrix = sprite.worldToLocalMatrix;
+
+            //We expect m_Bones to contain character's bones references if character exists. Sprite's skeleton bones otherwise.
+            if (skinningCache.hasCharacter)
+                worldToLocalMatrix = sprite.GetCharacterPart().worldToLocalMatrix;
+
+            SpriteBoneData spriteBoneData = null;
+            var bone = m_Bones[index];
+
+            if (bone == null)
+                spriteBoneData = new SpriteBoneData();
+            else
+            {
+                spriteBoneData = new SpriteBoneData()
+                {
+                    name = bone.name,
+                    parentId = bone.parentBone == null ? -1 : m_Bones.IndexOf(bone.parentBone),
+                    localPosition = bone.localPosition,
+                    localRotation = bone.localRotation,
+                    position = worldToLocalMatrix.MultiplyPoint3x4(bone.position),
+                    endPosition = worldToLocalMatrix.MultiplyPoint3x4(bone.endPosition),
+                    depth = bone.depth,
+                    length = bone.localLength
+                };
+            }
+
+            return spriteBoneData;
+        }
+
+        float ISpriteMeshData.GetBoneDepth(int index)
+        {
+            return m_Bones[index].depth;
+        }
+
+        public void Clear()
+        {
+            m_Vertices.Clear();
+            m_Indices.Clear();
+            m_Edges.Clear();
+        }
+
+        public bool ContainsBone(BoneCache bone)
+        {
+            return m_Bones.Contains(bone);
+        }
+
+        public void SetCompatibleBoneSet(BoneCache[] bones)
+        {
+            m_Bones = new List<BoneCache>(bones);
+        }
+
+        private void SetBones(BoneCache[] bones)
+        {
+            FixWeights(bones);
+            SetCompatibleBoneSet(bones);
+        }
+
+        private void FixWeights(BoneCache[] newBones)
+        {
+            var newBonesList = new List<BoneCache>(newBones);
+            var indexMap = new Dictionary<int, int>();
+
+            for (var i = 0; i < m_Bones.Count; ++i)
+            {
+                var bone = m_Bones[i];
+                var newIndex = newBonesList.IndexOf(bone);
+
+                if (newIndex != -1)
+                    indexMap.Add(i, newIndex);
+            }
+
+            foreach (Vertex2D vertex in vertices)
+            {
+                var boneWeight = vertex.editableBoneWeight;
+
+                for (var i = 0; i < boneWeight.Count; ++i)
+                {
+                    var newIndex = 0;
+                    var boneRemoved = indexMap.TryGetValue(boneWeight[i].boneIndex, out newIndex) == false;
+
+                    if (boneRemoved)
+                    {
+                        boneWeight[i].weight = 0f;
+                        boneWeight[i].enabled = false;
+                    }
+
+                    boneWeight[i].boneIndex = newIndex;
+
+                    if (boneRemoved)
+                        boneWeight.CompensateOtherChannels(i);
+                }
+
+                boneWeight.UnifyChannelsWithSameBoneIndex();
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..d563b71f693254feea51bedbed20c1b24ecf1429
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec847c6dc93e9e6459ad61443ca36507
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..87a7af0a075aee2f34d192166d1732e843f8a62d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs
@@ -0,0 +1,370 @@
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class MeshPreviewCache : SkinningObject
+    {
+        private const int kNiceColorCount = 6;
+
+        [SerializeField]
+        private SpriteCache m_Sprite;
+        [SerializeField]
+        private Mesh m_Mesh;
+        [SerializeField]
+        private Mesh m_DefaultMesh;
+        private List<Vector3> m_SkinnedVertices = new List<Vector3>();
+        private List<Vector3> m_Vertices = new List<Vector3>();
+        private List<BoneWeight> m_Weights = new List<BoneWeight>();
+        private List<Vector2> m_TexCoords = new List<Vector2>();
+        private List<Color> m_Colors = new List<Color>();
+        private List<Matrix4x4> m_SkinningMatrices = new List<Matrix4x4>();
+        private bool m_MeshDirty;
+        private bool m_VerticesDirty;
+        private bool m_SkinningDirty;
+        private bool m_WeightsDirty;
+        private bool m_IndicesDirty;
+        private bool m_ColorsDirty;
+        private bool m_EnableSkinning;
+
+        public SpriteCache sprite
+        {
+            get { return m_Sprite; }
+            set
+            {
+                m_Sprite = value;
+                InitializeDefaultMesh();
+                SetMeshDirty();
+            }
+        }
+
+        public Mesh mesh { get { return m_Mesh; } }
+        public Mesh defaultMesh { get { return m_DefaultMesh; } }
+
+        public bool enableSkinning
+        {
+            get
+            {
+                return m_EnableSkinning;
+            }
+
+            set
+            {
+                if (m_EnableSkinning != value)
+                {
+                    m_EnableSkinning = value;
+                    SetSkinningDirty();
+                }
+            }
+        }
+
+        public bool canSkin
+        {
+            get { return CanSkin(); }
+        }
+
+        public List<Vector3> vertices
+        {
+            get
+            {
+                if (enableSkinning && canSkin)
+                    return m_SkinnedVertices;
+
+                return m_Vertices;
+            }
+        }
+
+        private bool CanSkin()
+        {
+            if (m_Vertices.Count == 0 || m_Vertices.Count != m_Weights.Count)
+                return false;
+
+            var bones = sprite.GetBonesFromMode();
+
+            Debug.Assert(bones != null);
+
+            if (bones.Length == 0)
+                return false;
+
+            foreach (var weight in m_Weights)
+            {
+                if (weight.boneIndex0 < 0 || weight.boneIndex0 >= bones.Length ||
+                    weight.boneIndex1 < 0 || weight.boneIndex1 >= bones.Length ||
+                    weight.boneIndex2 < 0 || weight.boneIndex2 >= bones.Length ||
+                    weight.boneIndex3 < 0 || weight.boneIndex3 >= bones.Length)
+                    return false;
+            }
+
+            return true;
+        }
+
+        internal override void OnCreate()
+        {
+            m_Mesh = CreateMesh();
+            m_DefaultMesh = CreateMesh();
+        }
+
+        internal override void OnDestroy()
+        {
+            DestroyImmediate(m_Mesh);
+            DestroyImmediate(m_DefaultMesh);
+        }
+
+        private Mesh CreateMesh()
+        {
+            var mesh = new Mesh();
+            mesh.MarkDynamic();
+            mesh.hideFlags = HideFlags.DontSave;
+
+            return mesh;
+        }
+
+        private void InitializeDefaultMesh()
+        {
+            Debug.Assert(sprite != null);
+            Debug.Assert(m_DefaultMesh != null);
+
+            var meshCache = sprite.GetMesh();
+
+            Debug.Assert(meshCache != null);
+
+            int width, height;
+            meshCache.textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
+
+            var uvScale = new Vector2(1f / width, 1f / height);
+            Vector3 position = sprite.textureRect.position;
+            var size = sprite.textureRect.size;
+
+            var vertices = new List<Vector3>()
+            {
+                Vector3.zero,
+                new Vector3(0f, size.y, 0f),
+                new Vector3(size.x, 0f, 0f),
+                size,
+            };
+
+            var uvs = new List<Vector2>()
+            {
+                Vector3.Scale(vertices[0] + position, uvScale),
+                Vector3.Scale(vertices[1] + position, uvScale),
+                Vector3.Scale(vertices[2] + position, uvScale),
+                Vector3.Scale(vertices[3] + position, uvScale),
+            };
+
+            m_DefaultMesh.SetVertices(vertices);
+            m_DefaultMesh.SetUVs(0, uvs);
+            m_DefaultMesh.SetColors(new List<Color>
+            {
+                Color.black,
+                Color.black,
+                Color.black,
+                Color.black
+            });
+            m_DefaultMesh.SetIndices(new int[]
+            {
+                0, 1, 3, 0, 3, 2
+            },
+                MeshTopology.Triangles, 0);
+
+            m_DefaultMesh.UploadMeshData(false);
+        }
+
+        public void SetMeshDirty()
+        {
+            m_MeshDirty = true;
+        }
+
+        public void SetVerticesDirty()
+        {
+            m_VerticesDirty = true;
+        }
+
+        public void SetSkinningDirty()
+        {
+            m_SkinningDirty = true;
+        }
+
+        public void SetWeightsDirty()
+        {
+            m_WeightsDirty = true;
+        }
+
+        public void SetIndicesDirty()
+        {
+            m_IndicesDirty = true;
+        }
+
+        public void SetColorsDirty()
+        {
+            m_ColorsDirty = true;
+        }
+
+        public void Prepare()
+        {
+            var meshChanged = false;
+            var meshCache = sprite.GetMesh();
+
+            Debug.Assert(meshCache != null);
+
+            m_MeshDirty |= m_Vertices.Count != meshCache.vertices.Count;
+
+            if (m_MeshDirty)
+            {
+                m_Mesh.Clear();
+                m_VerticesDirty = true;
+                m_WeightsDirty = true;
+                m_IndicesDirty = true;
+                m_SkinningDirty = true;
+                m_MeshDirty = false;
+            }
+
+            if (m_VerticesDirty)
+            {
+                m_Vertices.Clear();
+                m_TexCoords.Clear();
+
+                int width, height;
+                meshCache.textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
+
+                var uvScale = new Vector2(1f / width, 1f / height);
+
+                foreach (var vertex in meshCache.vertices)
+                {
+                    m_Vertices.Add(vertex.position);
+                    m_TexCoords.Add(Vector2.Scale(vertex.position + sprite.textureRect.position, uvScale));
+                }
+
+                m_Mesh.SetVertices(m_Vertices);
+                m_Mesh.SetUVs(0, m_TexCoords);
+                meshChanged = true;
+                m_VerticesDirty = false;
+            }
+
+            if (m_WeightsDirty)
+            {
+                m_Weights.Clear();
+
+                for (int i = 0; i < meshCache.vertices.Count; ++i)
+                {
+                    var vertex = meshCache.vertices[i];
+                    m_Weights.Add(vertex.editableBoneWeight.ToBoneWeight(true));
+                }
+
+                SetColorsDirty();
+                meshChanged = true;
+                m_WeightsDirty = false;
+            }
+
+            if (m_ColorsDirty)
+            {
+                PrepareColors();
+
+                m_Mesh.SetColors(m_Colors);
+                meshChanged = true;
+                m_ColorsDirty = false;
+            }
+
+            if (m_IndicesDirty)
+            {
+                m_Mesh.SetTriangles(meshCache.indices, 0);
+                meshChanged = true;
+                m_IndicesDirty = false;
+            }
+
+            if (m_SkinningDirty)
+            {
+                if (enableSkinning && canSkin)
+                {
+                    SkinVertices();
+                    m_Mesh.SetVertices(m_SkinnedVertices);
+                    meshChanged = true;
+                }
+
+                m_SkinningDirty = false;
+            }
+
+            if (meshChanged)
+            {
+                m_Mesh.UploadMeshData(false);
+                m_Mesh.RecalculateBounds();
+                skinningCache.events.meshPreviewChanged.Invoke(this);
+            }
+        }
+
+        private void PrepareColors()
+        {
+            var bones = sprite.GetBonesFromMode();
+
+            Debug.Assert(bones != null);
+
+            m_Colors.Clear();
+
+            for (var i = 0; i < m_Weights.Count; ++i)
+            {
+                var boneWeight = m_Weights[i];
+                var weightSum = 0f;
+                var color = Color.black;
+
+                for (var j = 0; j < 4; ++j)
+                {
+                    var boneIndex = boneWeight.GetBoneIndex(j);
+                    var weight = boneWeight.GetWeight(j);
+
+                    if (boneIndex >= 0 && boneIndex < bones.Length)
+                        color += bones[boneIndex].bindPoseColor * weight;
+
+                    weightSum += weight;
+                }
+
+                color.a = 1f;
+
+                m_Colors.Add(Color.Lerp(Color.black, color, weightSum));
+            }
+        }
+
+        private void SkinVertices()
+        {
+            Debug.Assert(canSkin);
+            Debug.Assert(sprite != null);
+
+            var bones = sprite.GetBonesFromMode();
+
+            var originMatrix = Matrix4x4.TRS(sprite.pivotRectSpace, Quaternion.identity, Vector3.one);
+            var originInverseMatrix = originMatrix.inverse;
+            var spriteMatrix = sprite.GetLocalToWorldMatrixFromMode();
+            var spriteMatrixInv = spriteMatrix.inverse;
+
+            m_SkinnedVertices.Clear();
+            m_SkinningMatrices.Clear();
+
+            for (int i = 0; i < bones.Length; ++i)
+                m_SkinningMatrices.Add(spriteMatrixInv * originInverseMatrix * bones[i].localToWorldMatrix * bones[i].bindPose.matrix.inverse * spriteMatrix);
+
+            for (int i = 0; i < m_Vertices.Count; ++i)
+            {
+                var position = m_Vertices[i];
+                BoneWeight boneWeight = m_Weights[i];
+                float weightSum = boneWeight.weight0 + boneWeight.weight1 + boneWeight.weight2 + boneWeight.weight3;
+
+                if (weightSum > 0f)
+                {
+                    var weightSumInv = 1f / weightSum;
+                    var skinnedPosition = m_SkinningMatrices[boneWeight.boneIndex0].MultiplyPoint3x4(position) * boneWeight.weight0 * weightSumInv +
+                        m_SkinningMatrices[boneWeight.boneIndex1].MultiplyPoint3x4(position) * boneWeight.weight1 * weightSumInv +
+                        m_SkinningMatrices[boneWeight.boneIndex2].MultiplyPoint3x4(position) * boneWeight.weight2 * weightSumInv +
+                        m_SkinningMatrices[boneWeight.boneIndex3].MultiplyPoint3x4(position) * boneWeight.weight3 * weightSumInv;
+
+                    position = Vector3.Lerp(position, skinnedPosition, weightSum);
+                }
+
+                m_SkinnedVertices.Add(position);
+            }
+        }
+
+        protected override void OnAfterDeserialize()
+        {
+            SetMeshDirty();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..1e1bad5be23e9752211edeaed0602ae6eef1335a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/MeshPreviewCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22143b1295b3a684d8118f7fa6c0403d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs
new file mode 100644
index 0000000000000000000000000000000000000000..7c8394d542d205ce8373bd9ca2096ada446b1597
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs
@@ -0,0 +1,192 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SkeletonCache : TransformCache
+    {
+        [SerializeField]
+        private bool m_IsPosePreview = false;
+        [SerializeField]
+        private List<BoneCache> m_Bones = new List<BoneCache>();
+
+        public bool isPosePreview { get { return m_IsPosePreview; } }
+
+        public int BoneCount { get { return m_Bones.Count; } }
+
+        public virtual BoneCache[] bones
+        {
+            get { return m_Bones.ToArray(); }
+        }
+
+        public void AddBone(BoneCache bone)
+        {
+            AddBone(bone, true);
+        }
+
+        public void AddBone(BoneCache bone, bool worldPositionStays)
+        {
+            Debug.Assert(bone != null);
+            Debug.Assert(!Contains(bone));
+
+            if (bone.parent == null)
+                bone.SetParent(this, worldPositionStays);
+
+            m_Bones.Add(bone);
+        }
+
+        public void ReorderBones(IEnumerable<BoneCache> boneCache)
+        {
+            if (boneCache.Count() == m_Bones.Count)
+            {
+                foreach (var b in m_Bones)
+                {
+                    if (!boneCache.Contains(b))
+                        return;
+                }
+                m_Bones = boneCache.ToList();
+            }
+        }
+
+        public void DestroyBone(BoneCache bone)
+        {
+            Debug.Assert(bone != null);
+            Debug.Assert(Contains(bone));
+            
+            m_Bones.Remove(bone);
+            
+            var children = bone.children;
+            foreach (var child in children)
+                child.SetParent(bone.parent);
+
+            skinningCache.Destroy(bone);
+        }
+
+        public void SetDefaultPose()
+        {
+            foreach (var bone in m_Bones)
+                bone.SetDefaultPose();
+
+            m_IsPosePreview = false;
+        }
+
+        public void RestoreDefaultPose()
+        {
+            foreach (var bone in m_Bones)
+                bone.RestoreDefaultPose();
+
+            m_IsPosePreview = false;
+            skinningCache.events.skeletonPreviewPoseChanged.Invoke(this);
+        }
+
+        public void SetPosePreview()
+        {
+            m_IsPosePreview = true;
+        }
+
+        public BonePose[] GetLocalPose()
+        {
+            var pose = new List<BonePose>();
+
+            foreach (var bone in m_Bones)
+                pose.Add(bone.localPose);
+
+            return pose.ToArray();
+        }
+
+        public void SetLocalPose(BonePose[] pose)
+        {
+            Debug.Assert(m_Bones.Count == pose.Length);
+
+            for (var i = 0; i < m_Bones.Count; ++i)
+                m_Bones[i].localPose = pose[i];
+
+            m_IsPosePreview = true;
+        }
+
+        public BonePose[] GetWorldPose()
+        {
+            var pose = new List<BonePose>();
+
+            foreach (var bone in m_Bones)
+                pose.Add(bone.worldPose);
+
+            return pose.ToArray();
+        }
+
+        public void SetWorldPose(BonePose[] pose)
+        {
+            Debug.Assert(m_Bones.Count == pose.Length);
+
+            for (var i = 0; i < m_Bones.Count; ++i)
+            {
+                var bone = m_Bones[i];
+                var childWoldPose = bone.GetChildrenWoldPose();
+                bone.worldPose = pose[i];
+                bone.SetChildrenWorldPose(childWoldPose);
+            }
+
+            m_IsPosePreview = true;
+        }
+
+        public BoneCache GetBone(int index)
+        {
+            return m_Bones[index];
+        }
+
+        public int IndexOf(BoneCache bone)
+        {
+            return m_Bones.IndexOf(bone);
+        }
+
+        public bool Contains(BoneCache bone)
+        {
+            return m_Bones.Contains(bone);
+        }
+
+        public void Clear()
+        {
+            var roots = children;
+
+            foreach (var root in roots)
+                DestroyHierarchy(root);
+
+            m_Bones.Clear();
+        }
+
+        public string GetUniqueName(BoneCache bone)
+        {
+            Debug.Assert(Contains(bone));
+
+            var boneName = bone.name;
+            var names = m_Bones.ConvertAll(b => b.name);
+            var index = IndexOf(bone);
+            var count = 0;
+
+            Debug.Assert(index < names.Count);
+
+            for (var i = 0; i < index; ++i)
+                if (names[i].Equals(boneName))
+                    ++count;
+
+            if (count == 0)
+                return boneName;
+
+            return string.Format("{0} ({1})", boneName, count + 1);
+        }
+
+        private void DestroyHierarchy(TransformCache root)
+        {
+            Debug.Assert(root != null);
+
+            var children = root.children;
+
+            foreach (var child in children)
+                DestroyHierarchy(child);
+
+            skinningCache.Destroy(root);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e4b7064fd540f391b8ab73d03983186f6ed5e6e8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/SkeletonCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9fd71ece24e4d504ba204588a27de2cc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCache.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCache.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b90994dafd660c718db779cf9806bcfe60752fa0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCache.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a43eacb849c08fa47b752df4f2e05c7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..252cf1f1528c401c3c1a341e62225961f7a91b9e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Linq;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class TransformCacheExtensions
+    {
+        internal static bool IsDescendant<T>(this T transform, T ancestor) where T : TransformCache
+        {
+            if (ancestor != null)
+            {
+                var parent = transform.parent;
+
+                while (parent != null)
+                {
+                    if (parent == ancestor)
+                        return true;
+
+                    parent = parent.parent;
+                }
+            }
+
+            return false;
+        }
+
+        internal static bool IsDescendant<T>(this T transform, T[] ancestors) where T : TransformCache
+        {
+            return ancestors.FirstOrDefault( t => transform.IsDescendant<T>(t) ) != null;
+        }
+
+        internal static T[] FindRoots<T>(this T[] transforms) where T : TransformCache
+        {
+            return transforms.Where(t => t.IsDescendant(transforms) == false).ToArray();
+        }
+
+        internal static T FindRoot<T>(this T transform, T[] transforms) where T : TransformCache
+        {
+            var roots = transforms.FindRoots<T>();
+            return roots.FirstOrDefault( r => transform == r || IsDescendant<T>(transform, r) );
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5dd5e5a49145070d34c2f40e1f9f60976c47c937
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCache/TransformCacheExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 51ee03bc936f1bf4489c0ee8696ebab7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs
new file mode 100644
index 0000000000000000000000000000000000000000..edbb41be9b946cda68e9c93c4a78f1dfb0000010
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs
@@ -0,0 +1,34 @@
+namespace UnityEditor.U2D.Animation
+{
+    internal static class SkinningCopyUtility
+    {
+        private static ISkinningSerializer s_SkinningSerializer = new SkinningSerializerJSON();
+        public static ISkinningSerializer Serializer
+        {
+            get { return s_SkinningSerializer; }
+            set { s_SkinningSerializer = value; }
+        }
+
+        public static string SerializeSkinningCopyDataToString(SkinningCopyData skinningData)
+        {
+            return s_SkinningSerializer.Serialize(skinningData);
+        }
+
+        public static bool CanDeserializeSystemCopyBufferToSkinningCopyData()
+        {
+            if (!string.IsNullOrEmpty(EditorGUIUtility.systemCopyBuffer))
+                return CanDeserializeStringToSkinningCopyData(EditorGUIUtility.systemCopyBuffer);
+            return false;
+        }
+
+        public static bool CanDeserializeStringToSkinningCopyData(string data)
+        {
+            return s_SkinningSerializer.CanDeserialize(data);
+        }
+
+        public static SkinningCopyData DeserializeStringToSkinningCopyData(string data)
+        {
+            return s_SkinningSerializer.Deserialize(data);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..37217672f744168d7389ec670028f9a94ab68970
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningCopyUtility.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: efabf946c69d212429c75db0d9aa9d1a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs
new file mode 100644
index 0000000000000000000000000000000000000000..22b89af4f6879b566b576b19d55787be819118ed
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface ISkinningSerializer
+    {
+        bool CanDeserialize(string data);
+        SkinningCopyData Deserialize(string data);
+        string Serialize(SkinningCopyData skinningData);
+    }
+
+    [Serializable]
+    internal class SpriteBoneCopyData
+    {
+        public UnityEngine.U2D.SpriteBone spriteBone;
+        public int order;
+    }
+
+    [Serializable]
+    internal class SkinningCopySpriteData
+    {
+        public string spriteName;
+        public List<SpriteBoneCopyData> spriteBones;
+        public List<Vertex2D> vertices;
+        public List<int> indices;
+        public List<Edge> edges;
+        public List<string> boneWeightNames;
+    }
+
+    [Serializable]
+    internal class SkinningCopyData
+    {
+        public float pixelsPerUnit;
+        public List<SkinningCopySpriteData> copyData = new List<SkinningCopySpriteData>();
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..0f33f05386318e40f17d1ee7d03a6bcd6b6ccc33
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/ISkinningSerializer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 65760d058db37cb438c9002fb9c5dc92
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs
new file mode 100644
index 0000000000000000000000000000000000000000..90b7005a1ced695c5227ceea26b5bc59f26649d5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs
@@ -0,0 +1,31 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SkinningSerializerJSON : ISkinningSerializer
+    {
+        public bool CanDeserialize(string data)
+        {
+            bool result = true;
+            try
+            {
+                JsonUtility.FromJson<SkinningCopyData>(data);
+            }
+            catch
+            {
+                result = false;
+            }
+            return result;
+        }
+
+        public SkinningCopyData Deserialize(string data)
+        {
+            return JsonUtility.FromJson<SkinningCopyData>(data);
+        }
+
+        public string Serialize(SkinningCopyData skinningData)
+        {
+            return JsonUtility.ToJson(skinningData);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..3139052e969619ea557cf6006ef5535f6d560edb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerJSON.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 171c69f47e06f2d47ab4225b6afbb5db
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs
new file mode 100644
index 0000000000000000000000000000000000000000..0fb729df14458bf27405d9dfc0825bc1b32dbdae
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SkinningXMLSerializer : ISkinningSerializer
+    {
+        public bool CanDeserialize(string data)
+        {
+            bool result = false;
+            try
+            {
+                using (TextReader textReader = new StringReader(data))
+                {
+                    using (XmlTextReader xmlReader = new XmlTextReader(textReader))
+                    {
+                        var xmlSerializer = new XmlSerializer(typeof(List<UnityEngine.U2D.SpriteBone>));
+                        result = xmlSerializer.CanDeserialize(xmlReader);
+                    }
+                }
+            }
+            catch
+            {
+            }
+            return result;
+        }
+
+        public SkinningCopyData Deserialize(string data)
+        {
+            SkinningCopyData skinningCopyData;
+            using (TextReader textReader = new StringReader(data))
+            {
+                using (XmlTextReader xmlReader = new XmlTextReader(textReader))
+                {
+                    var xmlSerializer = new XmlSerializer(typeof(SkinningCopyData));
+                    if (!xmlSerializer.CanDeserialize(xmlReader))
+                    {
+                        throw new InvalidOperationException(
+                            "Unable to deserialize system copy buffer to Skinning Copy Data");
+                    }
+                    skinningCopyData = (SkinningCopyData)xmlSerializer.Deserialize(xmlReader);
+                }
+            }
+            return skinningCopyData;
+        }
+
+        public string Serialize(SkinningCopyData skinningData)
+        {
+            XmlSerializer xmlSerializer = new XmlSerializer(skinningData.GetType());
+            using (StringWriter textWriter = new StringWriter())
+            {
+                xmlSerializer.Serialize(textWriter, skinningData);
+                return textWriter.ToString();
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..ef7b42c238cade2b0d85973ea2d60dad1229f475
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SkinningSerializer/SkinningSerializerXML.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9aa1c187477fd364bb93e6f97f16c9fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c7d09520113324182d042bb8c5759bbcd757a83b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SelectListView : ListView
+    {
+        public class CustomUxmlFactory : UxmlFactory<SelectListView, UxmlTraits> {}
+
+        public new void AddToSelection(int index)
+        {
+            base.AddToSelection(index);
+        }
+
+        public new void ClearSelection()
+        {
+            base.ClearSelection();
+        }
+    }
+
+    internal class SpriteBoneInfluenceListWidget : VisualElement
+    {
+        public class CustomUxmlFactory : UxmlFactory<SpriteBoneInfluenceListWidget, CustomUxmlTraits> {}
+        public class CustomUxmlTraits : UxmlTraits {}
+
+        private List<BoneCache> m_BoneInfluences;
+        private SelectListView m_ListView;
+        bool m_IgnoreSelectionChange = false;
+        private Button m_AddButton;
+        private Button m_RemoveButton;
+        public Action onAddBone = () => {};
+        public Action onRemoveBone = () => {};
+        public Action<IEnumerable<BoneCache>> onReordered = _ => {};
+        public Action<IEnumerable<BoneCache>> onSelectionChanged = (s) => {};
+        public Func<SpriteBoneInflueceToolController> GetController = () => null;
+
+        public SpriteBoneInfluenceListWidget()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/SpriteBoneInfluenceListWidget.uxml");
+            var ve = visualTree.CloneTree().Q("Container");
+            ve.styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/SpriteBoneInfluenceListWidgetStyle.uss"));
+            if (EditorGUIUtility.isProSkin)
+                AddToClassList("Dark");
+            this.Add(ve);
+            BindElements();
+        }
+
+        private void BindElements()
+        {
+            m_ListView = this.Q<SelectListView>();
+            m_ListView.selectionType = SelectionType.Multiple;
+            m_ListView.itemsSource = m_BoneInfluences;
+            m_ListView.makeItem = () =>
+            {
+                var label = new Label()
+                {
+                    name = "ListRow"
+                };
+                return label;
+            };
+            m_ListView.bindItem = (e, index) =>
+            {
+                if (m_BoneInfluences[index] == null)
+                    return;
+
+                (e as Label).text = m_BoneInfluences[index].name;
+                if (index % 2 == 0)
+                {
+                    e.RemoveFromClassList("ListRowOddColor");
+                    e.AddToClassList("ListRowEvenColor");
+                }
+                else
+                {
+                    e.RemoveFromClassList("ListRowEvenColor");
+                    e.AddToClassList("ListRowOddColor");
+                }
+            };
+
+            m_ListView.onSelectionChange += OnListViewSelectionChanged;
+            m_AddButton = this.Q<Button>("AddButton");
+            m_AddButton.clickable.clicked += OnAddButtonClick;
+            m_RemoveButton = this.Q<Button>("RemoveButton");
+            m_RemoveButton.clickable.clicked += OnRemoveButtonClick;
+            this.RegisterCallback<DragPerformEvent>(x => onReordered(m_BoneInfluences) );
+        }
+
+        private void OnListViewSelectionChanged(IEnumerable<object> o)
+        {
+            if (m_IgnoreSelectionChange)
+                return;
+
+            var selectedBones = o.OfType<BoneCache>().ToArray();
+
+            onSelectionChanged(selectedBones);
+        }
+
+        private void OnAddButtonClick()
+        {
+            onAddBone();
+        }
+
+        private void OnRemoveButtonClick()
+        {
+            onRemoveBone();
+        }
+
+        public void Update()
+        {
+            m_BoneInfluences = GetController().GetSelectedSpriteBoneInfluence().ToList();
+            m_ListView.itemsSource = m_BoneInfluences;
+            m_ListView.Refresh();
+        }
+
+        internal void OnBoneSelectionChanged()
+        {
+            var selectedBones = GetController().GetSelectedBoneForList(m_BoneInfluences);
+            m_IgnoreSelectionChange = true;
+            m_ListView.ClearSelection();
+            foreach (var bone in selectedBones)
+            {
+                m_ListView.AddToSelection(bone);
+            }
+            m_IgnoreSelectionChange = false;
+            m_AddButton.SetEnabled(GetController().ShouldEnableAddButton(m_BoneInfluences));
+            m_RemoveButton.SetEnabled(GetController().InCharacterMode() && m_ListView.selectedIndex >= 0);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..08acf167749bf2eeb457bc0e3596f5e06284ffcb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceListWidget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6111684d389380840a9e782a0936a829
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..4cb81508630adf7b2e0a0ddd8c33b6948f3be346
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs
@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.U2D.Layout;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SpriteBoneInflueceToolController
+    {
+        SkinningEvents m_Events;
+        ISpriteBoneInfluenceToolModel m_Model;
+        public SpriteBoneInflueceToolController(ISpriteBoneInfluenceToolModel model, SkinningEvents events)
+        {
+            m_Events = events;
+            m_Model = model;
+        }
+
+        public void Activate()
+        {
+            m_Events.selectedSpriteChanged.AddListener(OnSpriteSelectionChanged);
+            m_Events.boneSelectionChanged.AddListener(OnBoneSelectionChanged);
+            m_Events.boneNameChanged.AddListener(OnBoneNameChanged);
+            m_Events.skeletonTopologyChanged.AddListener(OnSkeletonTopologyChanged);
+            m_Events.meshChanged.AddListener(OnMeshChanged);
+            ShowHideView(true);
+            OnBoneSelectionChanged();
+        }
+
+        public void Deactivate()
+        {
+            m_Events.selectedSpriteChanged.RemoveListener(OnSpriteSelectionChanged);
+            m_Events.boneSelectionChanged.RemoveListener(OnBoneSelectionChanged);
+            m_Events.boneNameChanged.RemoveListener(OnBoneNameChanged);
+            m_Events.skeletonTopologyChanged.RemoveListener(OnSkeletonTopologyChanged);
+            m_Events.meshChanged.RemoveListener(OnMeshChanged);
+            ShowHideView(false);
+        }
+
+        private void OnMeshChanged(MeshCache mesh)
+        {
+            if (m_Model.view.visible)
+                m_Model.view.OnMeshChanged();
+        }
+
+        private void OnSpriteSelectionChanged(SpriteCache sprite)
+        {
+            if (m_Model.view.visible)
+            {
+                m_Model.view.OnSpriteSelectionChanged();
+                SetViewHeaderText();
+            }
+        }
+
+        private void OnBoneSelectionChanged()
+        {
+            if (m_Model.view.visible)
+                m_Model.view.OnBoneSelectionChanged();
+        }
+
+        private void OnBoneNameChanged(BoneCache bone)
+        {
+            if (m_Model.view.visible)
+            {
+                m_Model.view.OnSkeletonChanged();
+            }
+        }
+
+        private void OnSkeletonTopologyChanged(SkeletonCache skeleton)
+        {
+            if (m_Model.view.visible)
+                m_Model.view.OnSkeletonChanged();
+        }
+
+        public void OnViewCreated()
+        {
+            m_Model.view.onAddBone += AddSelectedBoneInfluencetoSprite;
+            m_Model.view.onRemoveBone += RemoveSelectedBoneInfluenceFromSprite;
+            m_Model.view.onReordered += OnReorderBoneInfluenceFromSprite;
+            m_Model.view.onSelectionChanged += SelectBones;
+            m_Model.view.SetController(this);
+            ShowHideView(false);
+        }
+
+        private void AddSelectedBoneInfluencetoSprite()
+        {
+            var character = m_Model.characterSkeleton;
+
+            if (character == null)
+                return;
+
+            var characterPart = m_Model.GetSpriteCharacterPart(m_Model.selectedSprite);
+            var selectedBones = m_Model.selectedBones;
+            var characterBones = characterPart.bones.ToList();
+
+            foreach (var bone in selectedBones)
+            {
+                if (!characterBones.Contains(bone))
+                    characterBones.Add(bone);
+            }
+
+            using (m_Model.UndoScope(TextContent.addBoneInfluence))
+            {
+                characterPart.bones = characterBones.ToArray();
+                m_Events.characterPartChanged.Invoke(characterPart);
+                m_Model.view.OnSkeletonChanged();
+                m_Model.view.OnBoneSelectionChanged();
+            }
+        }
+
+        private void RemoveSelectedBoneInfluenceFromSprite()
+        {
+            var character = m_Model.characterSkeleton;
+
+            if (character == null)
+                return;
+
+            var characterPart = m_Model.GetSpriteCharacterPart(m_Model.selectedSprite);
+            var selectedBones = m_Model.selectedBones;
+            var characterBones = characterPart.bones.ToList();
+
+            characterBones.RemoveAll(b => selectedBones.Contains(b));
+
+            using (m_Model.UndoScope(TextContent.removeBoneInfluence))
+            {
+                characterPart.bones = characterBones.ToArray();
+                m_Events.characterPartChanged.Invoke(characterPart);
+                
+                characterPart.sprite.SmoothFill();
+                m_Events.meshChanged.Invoke(characterPart.sprite.GetMesh());
+
+                m_Model.view.OnSkeletonChanged();
+                m_Model.view.OnBoneSelectionChanged();
+            }
+        }
+
+        private void OnReorderBoneInfluenceFromSprite(IEnumerable<BoneCache> boneCache)
+        {
+            var character = m_Model.characterSkeleton;
+
+            if (character != null)
+            {
+                var characterPart = m_Model.GetSpriteCharacterPart(m_Model.selectedSprite);
+                using (m_Model.UndoScope(TextContent.reorderBoneInfluence))
+                {
+                    characterPart.bones = boneCache.ToArray();
+                    m_Events.characterPartChanged.Invoke(characterPart);
+                    m_Model.view.OnSkeletonChanged();
+                }
+            }
+            else
+            {
+                using (m_Model.UndoScope(TextContent.reorderBoneInfluence))
+                {
+                    m_Model.selectedSprite.GetSkeleton().ReorderBones(boneCache);
+                    m_Events.skeletonTopologyChanged.Invoke(m_Model.selectedSprite.GetSkeleton());
+                }
+            }
+        }
+
+        private void SelectBones(IEnumerable<BoneCache> selectedBones)
+        {
+            using (m_Model.UndoScope(TextContent.boneSelection))
+            {
+                m_Model.selectedBones = selectedBones;
+                m_Events.boneSelectionChanged.Invoke();
+            }
+        }
+
+        private void ShowHideView(bool show)
+        {
+            m_Model.view.SetHiddenFromLayout(!show);
+            if (show)
+            {
+                m_Model.view.OnSpriteSelectionChanged();
+                SetViewHeaderText();
+            }
+        }
+
+        private void SetViewHeaderText()
+        {
+            var headerText = m_Model.selectedSprite != null ? m_Model.selectedSprite.name : TextContent.noSpriteSelected;
+            m_Model.view.headerText = headerText;
+        }
+
+        public BoneCache[] GetSelectedSpriteBoneInfluence()
+        {
+            var selectedSprite = m_Model.selectedSprite;
+
+            if (selectedSprite != null)
+            {
+                if (m_Model.hasCharacter)
+                {
+                    var characterPart = m_Model.GetSpriteCharacterPart(selectedSprite);
+                    return characterPart.bones.ToArray();
+                }
+                else
+                {
+                    return selectedSprite.GetSkeleton().bones;
+                }
+            }
+            return new BoneCache[0];
+        }
+
+        public int[] GetSelectedBoneForList(IEnumerable<BoneCache> bones)
+        {
+            var selectedBones = m_Model.selectedBones;
+            var spriteBones = GetSelectedSpriteBoneInfluence();
+            var result = new List<int>();
+            foreach (var bone in selectedBones)
+            {
+                var index = Array.IndexOf(spriteBones, bone);
+                if (index >= 0)
+                    result.Add(index);
+            }
+            return result.ToArray();
+        }
+
+        public bool ShouldEnableAddButton(IEnumerable<BoneCache> bones)
+        {
+            if (InCharacterMode())
+            {
+                var hasSelectedSprite = m_Model.selectedSprite != null;
+                var selectedBones = m_Model.selectedBones;
+                return hasSelectedSprite && selectedBones.FirstOrDefault(x => !bones.Contains(x)) != null;
+            }
+            return false;
+        }
+
+        public bool InCharacterMode()
+        {
+            return m_Model.hasCharacter && m_Model.skinningMode == SkinningMode.Character;
+        }
+    }
+
+    internal interface ISpriteBoneInfluenceToolModel
+    {
+        ISpriteBoneInfluenceWindow view { get; }
+        IEnumerable<BoneCache> selectedBones { get; set; }
+        SpriteCache selectedSprite { get; }
+        bool hasCharacter { get; }
+        SkinningMode skinningMode { get; }
+        SkeletonCache characterSkeleton { get; }
+        UndoScope UndoScope(string description);
+        CharacterPartCache GetSpriteCharacterPart(SpriteCache sprite);
+    }
+
+    internal class SpriteBoneInfluenceTool : BaseTool, ISpriteBoneInfluenceToolModel
+    {
+        SpriteBoneInflueceToolController m_Controller;
+        private MeshPreviewBehaviour m_MeshPreviewBehaviour = new MeshPreviewBehaviour();
+        private SpriteBoneInfluenceWindow m_View;
+
+        public SkeletonTool skeletonTool { set; private get; }
+        public override IMeshPreviewBehaviour previewBehaviour
+        {
+            get { return m_MeshPreviewBehaviour; }
+        }
+
+        internal override void OnCreate()
+        {
+            m_Controller = new SpriteBoneInflueceToolController(this, skinningCache.events);
+        }
+
+        ISpriteBoneInfluenceWindow ISpriteBoneInfluenceToolModel.view {get { return m_View; } }
+
+        IEnumerable<BoneCache> ISpriteBoneInfluenceToolModel.selectedBones
+        {
+            get { return skinningCache.skeletonSelection.elements; }
+            set { skinningCache.skeletonSelection.elements = value.ToArray(); }
+        }
+        SpriteCache ISpriteBoneInfluenceToolModel.selectedSprite { get { return skinningCache.selectedSprite; } }
+        bool ISpriteBoneInfluenceToolModel.hasCharacter { get { return skinningCache.hasCharacter; } }
+        SkinningMode ISpriteBoneInfluenceToolModel.skinningMode { get { return skinningCache.mode; } }
+        SkeletonCache ISpriteBoneInfluenceToolModel.characterSkeleton { get { return skinningCache.character != null ? skinningCache.character.skeleton : null; } }
+
+        UndoScope ISpriteBoneInfluenceToolModel.UndoScope(string description)
+        {
+            return skinningCache.UndoScope(description);
+        }
+
+        protected override void OnActivate()
+        {
+            m_Controller.Activate();
+            if (skeletonTool != null)
+                skeletonTool.Activate();
+        }
+
+        protected override void OnDeactivate()
+        {
+            m_Controller.Deactivate();
+            if (skeletonTool != null)
+                skeletonTool.Deactivate();
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            if (m_View == null)
+            {
+                m_View = SpriteBoneInfluenceWindow.CreateFromUXML();
+                m_Controller.OnViewCreated();
+            }
+
+            layout.rightOverlay.Add(m_View);
+        }
+
+        protected override void OnGUI()
+        {
+            m_MeshPreviewBehaviour.showWeightMap = true;
+            m_MeshPreviewBehaviour.overlaySelected = true;
+            m_MeshPreviewBehaviour.drawWireframe = true;
+
+            skeletonTool.skeletonStyle = SkeletonStyles.WeightMap;
+            skeletonTool.mode = SkeletonMode.EditPose;
+            skeletonTool.editBindPose = false;
+            skeletonTool.DoGUI();
+        }
+
+        public CharacterPartCache GetSpriteCharacterPart(SpriteCache sprite)
+        {
+            return sprite.GetCharacterPart();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..0279069146b92310a09ae28a19a8435a6e127a7d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f7836643c0cc9724c94363180ebebd47
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs
new file mode 100644
index 0000000000000000000000000000000000000000..4ee97cdbf8f23a72c3b8b5c09f4c48c2e7c23dbd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    using PopupWindow = UnityEngine.UIElements.PopupWindow;
+
+    internal interface ISpriteBoneInfluenceWindow
+    {
+        string headerText { get; set; }
+        void SetHiddenFromLayout(bool hide);
+        void OnSpriteSelectionChanged();
+        void OnSkeletonChanged();
+        void OnMeshChanged();
+        bool visible { get; }
+        void OnBoneSelectionChanged();
+        event Action onAddBone;
+        event Action onRemoveBone;
+        event Action<IEnumerable<BoneCache>> onReordered;
+        event Action<IEnumerable<BoneCache>> onSelectionChanged;
+        void SetController(SpriteBoneInflueceToolController controller);
+    }
+
+    internal class SpriteBoneInfluenceWindow : VisualElement, ISpriteBoneInfluenceWindow
+    {
+        public class CustomUxmlFactory : UxmlFactory<SpriteBoneInfluenceWindow, UxmlTraits> {}
+
+        private SpriteBoneInfluenceListWidget m_InfluencesList;
+        private PopupWindow m_HeaderLabel;
+        SpriteBoneInflueceToolController m_Controller;
+
+        public event Action onAddBone = () => {};
+        public event Action onRemoveBone = () => {};
+        public event Action<IEnumerable<BoneCache>> onReordered = _ => {};
+        public event Action<IEnumerable<BoneCache>> onSelectionChanged = _ => {};
+
+        public string headerText
+        {
+            get { return m_HeaderLabel.text; }
+            set { m_HeaderLabel.text = value; }
+        }
+
+        static internal SpriteBoneInfluenceWindow CreateFromUXML()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/SpriteBoneInfluenceWindow.uxml");
+            var ve = visualTree.CloneTree().Q("SpriteBoneInfluenceWindow") as SpriteBoneInfluenceWindow;
+            ve.BindElements();
+            return ve;
+        }
+
+        internal void BindElements()
+        {
+            m_InfluencesList = this.Q<SpriteBoneInfluenceListWidget>();
+            m_InfluencesList.onAddBone = () => onAddBone();
+            m_InfluencesList.onRemoveBone = () => onRemoveBone();
+            m_InfluencesList.onReordered = s => onReordered(s);
+            m_InfluencesList.onSelectionChanged = (s) => onSelectionChanged(s);
+            m_InfluencesList.GetController = InternalGetController;
+            m_HeaderLabel = this.Q<PopupWindow>();
+            this.styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/SpriteBoneInfluenceWindowStyle.uss"));
+        }
+
+        SpriteBoneInflueceToolController InternalGetController()
+        {
+            return m_Controller;
+        }
+
+        public void OnSpriteSelectionChanged()
+        {
+            Update();
+        }
+
+        public void OnMeshChanged()
+        {
+            Update();
+        }
+
+        public void OnSkeletonChanged()
+        {
+            m_InfluencesList.Update();
+        }
+
+        public void OnBoneSelectionChanged()
+        {
+            m_InfluencesList.OnBoneSelectionChanged();
+        }
+
+        private void Update()
+        {
+            m_InfluencesList.Update();
+            m_InfluencesList.OnBoneSelectionChanged();
+        }
+
+        void ISpriteBoneInfluenceWindow.SetController(SpriteBoneInflueceToolController controller)
+        {
+            m_Controller = controller;
+        }
+
+        void ISpriteBoneInfluenceWindow.SetHiddenFromLayout(bool hide)
+        {
+            this.SetHiddenFromLayout(hide);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b4841fa53a70608667091580aa7f2a63ef7cbb7c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteBoneInfluence/SpriteBoneInfluenceWindow.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acaa2d82522f0dd45b4dc5ce9c7dcff0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..8d72b9da4ee022f3bd9fd5e9525b04b40defa04a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs
@@ -0,0 +1,91 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class BoneWeightExtensions
+    {
+        public static int GetBoneIndex(this BoneWeight boneWeight, int channelIndex)
+        {
+            if (channelIndex < 0 || channelIndex >= 4)
+                throw new ArgumentOutOfRangeException("Channel index out of range");
+
+            if (channelIndex == 0)
+                return boneWeight.boneIndex0;
+            if (channelIndex == 1)
+                return boneWeight.boneIndex1;
+            if (channelIndex == 2)
+                return boneWeight.boneIndex2;
+            if (channelIndex == 3)
+                return boneWeight.boneIndex3;
+            return -1;
+        }
+
+        public static void SetBoneIndex(ref BoneWeight boneWeight, int channelIndex, int boneIndex)
+        {
+            if (channelIndex < 0 || channelIndex >= 4)
+                throw new ArgumentOutOfRangeException("Channel index out of range");
+
+            if (channelIndex == 0)
+                boneWeight.boneIndex0 = boneIndex;
+            if (channelIndex == 1)
+                boneWeight.boneIndex1 = boneIndex;
+            if (channelIndex == 2)
+                boneWeight.boneIndex2 = boneIndex;
+            if (channelIndex == 3)
+                boneWeight.boneIndex3 = boneIndex;
+        }
+
+        public static float GetWeight(this BoneWeight boneWeight, int channelIndex)
+        {
+            if (channelIndex < 0 || channelIndex >= 4)
+                throw new ArgumentOutOfRangeException("Channel index out of range");
+
+            if (channelIndex == 0)
+                return boneWeight.weight0;
+            if (channelIndex == 1)
+                return boneWeight.weight1;
+            if (channelIndex == 2)
+                return boneWeight.weight2;
+            if (channelIndex == 3)
+                return boneWeight.weight3;
+            return 0f;
+        }
+
+        public static void SetWeight(ref BoneWeight boneWeight, int channelIndex, float weight)
+        {
+            if (channelIndex < 0 || channelIndex >= 4)
+                throw new ArgumentOutOfRangeException("Channel index out of range");
+
+            if (channelIndex == 0)
+                boneWeight.weight0 = weight;
+            if (channelIndex == 1)
+                boneWeight.weight1 = weight;
+            if (channelIndex == 2)
+                boneWeight.weight2 = weight;
+            if (channelIndex == 3)
+                boneWeight.weight3 = weight;
+        }
+
+        public static float Sum(this BoneWeight boneWeight)
+        {
+            return boneWeight.weight0 + boneWeight.weight1 + boneWeight.weight2 + boneWeight.weight3;
+        }
+
+        public static BoneWeight Normalized(this BoneWeight boneWeight)
+        {
+            var sum = boneWeight.Sum();
+            
+            if (sum == 0 || sum == 1f)
+                return boneWeight;
+
+            var normalized = boneWeight;
+            var sumInv = 1f / sum;
+
+            for (var i = 0; i < 4; ++i)
+                SetWeight(ref normalized, i, normalized.GetWeight(i) * sumInv);
+
+            return normalized;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c3f59f4095ab5d151fe78525b9748f7654c2c9aa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/BoneWeightExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4ccab030e59cd542a67539ba0c86549
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6b63b5b2188a417831907f2a205dc46d83ac89ce
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs
@@ -0,0 +1,62 @@
+using UnityEngine;
+using System;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal struct Edge
+    {
+        [SerializeField]
+        int m_Index1;
+        [SerializeField]
+        int m_Index2;
+
+        public int index1
+        {
+            get { return m_Index1; }
+            set { m_Index1 = value; }
+        }
+
+        public int index2
+        {
+            get { return m_Index2; }
+            set { m_Index2 = value; }
+        }
+
+        public Edge(int inIndex1, int inIndex2)
+        {
+            m_Index1 = inIndex1;
+            m_Index2 = inIndex2;
+        }
+
+        public bool Contains(int index)
+        {
+            return index1 == index || index2 == index;
+        }
+
+        public static bool operator==(Edge lhs, Edge rhs)
+        {
+            return lhs.Equals(rhs);
+        }
+
+        public static bool operator!=(Edge lhs, Edge rhs)
+        {
+            return !lhs.Equals(rhs);
+        }
+
+        public override bool Equals(System.Object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+                return false;
+
+            Edge p = (Edge)obj;
+
+            return (index1 == p.index1) && (index2 == p.index2) || (index1 == p.index2) && (index2 == p.index1);
+        }
+
+        public override int GetHashCode()
+        {
+            return index1.GetHashCode() ^ index2.GetHashCode();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..3c899890b5f0ed441d32ea0889881d1a40fcfe9f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Edge.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9d39e60df00ea46b4af0f2ee69c0541b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/EditableBoneWeight.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/EditableBoneWeight.cs
new file mode 100644
index 0000000000000000000000000000000000000000..76a9372cfb101f7f3d4b20a5f032512003f82067
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/EditableBoneWeight.cs
@@ -0,0 +1,108 @@
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal class BoneWeightChannel : IComparable<BoneWeightChannel>
+    {
+        [SerializeField]
+        private bool m_Enabled;
+        [SerializeField]
+        private int m_BoneIndex;
+        [SerializeField]
+        private float m_Weight;
+
+        public bool enabled
+        {
+            get { return m_Enabled; }
+            set { m_Enabled = value; }
+        }
+
+        public int boneIndex
+        {
+            get { return m_BoneIndex; }
+            set { m_BoneIndex = value; }
+        }
+
+        public float weight
+        {
+            get { return m_Weight; }
+            set { m_Weight = value; }
+        }
+
+        public BoneWeightChannel() : this(0, 0f, false)
+        {
+
+        }
+
+        public BoneWeightChannel(int i, float w, bool e)
+        {
+            enabled = e;
+            boneIndex = i;
+            weight = w;
+        }
+
+        public int CompareTo(BoneWeightChannel other)
+        {
+            int result = other.enabled.CompareTo(enabled);
+
+            if (result == 0)
+                result = other.weight.CompareTo(weight);
+
+            return result;
+        }
+    }
+
+    [Serializable]
+    internal class EditableBoneWeight : IEnumerable<BoneWeightChannel>
+    {
+        [SerializeField]
+        private List<BoneWeightChannel> m_Channels = new List<BoneWeightChannel>(5);
+
+        public BoneWeightChannel this[int i]
+        {
+            get { return m_Channels[i]; }
+            set { m_Channels[i] = value; }
+        }
+
+        public int Count
+        {
+            get { return m_Channels.Count; }
+        }
+
+        public void Clear()
+        {
+            m_Channels.Clear();
+        }
+
+        public void AddChannel(int boneIndex, float weight, bool enabled)
+        {
+            m_Channels.Add(new BoneWeightChannel(boneIndex, weight, enabled));
+        }
+
+        public void RemoveChannel(int channelIndex)
+        {
+            Debug.Assert(channelIndex < Count);
+
+            m_Channels.RemoveAt(channelIndex);
+        }
+
+        public void Sort()
+        {
+            m_Channels.Sort();
+        }
+
+        public IEnumerator<BoneWeightChannel> GetEnumerator()
+        {
+            return ((IEnumerable<BoneWeightChannel>)m_Channels).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<BoneWeightChannel>)m_Channels).GetEnumerator();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/SpriteMeshDataController.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/SpriteMeshDataController.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5dee194ef38818cefa32d64eff6dcc732b95dfb9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/SpriteMeshDataController.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b0085fc7caad034f8513c17d7e40646
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs
new file mode 100644
index 0000000000000000000000000000000000000000..ea432cdb6d560d74dba76f92ca55dc6805ed30dc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs
@@ -0,0 +1,39 @@
+using UnityEngine;
+using System;
+
+namespace UnityEditor.U2D.Animation
+{
+    [Serializable]
+    internal class Vertex2D
+    {
+        public Vector2 position
+        {
+            get { return m_Position; }
+            set { m_Position = value; }
+        }
+
+        public EditableBoneWeight editableBoneWeight
+        {
+            get { return m_EditableBoneWeight; }
+            set { m_EditableBoneWeight = value; }
+        }
+
+        public Vertex2D(Vector2 position)
+        {
+            m_Position = position;
+            m_EditableBoneWeight = EditableBoneWeightUtility.CreateFromBoneWeight(new BoneWeight());
+        }
+
+        public Vertex2D(Vector2 position, BoneWeight weights)
+        {
+            m_Position = position;
+            m_EditableBoneWeight = EditableBoneWeightUtility.CreateFromBoneWeight(weights);
+        }
+
+        [SerializeField]
+        Vector2 m_Position;
+
+        [SerializeField]
+        EditableBoneWeight m_EditableBoneWeight;
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..9845160385aa754762c7d878898cbcba8b66bf53
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/Vertex2D.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 879d7ab84cd1a4d3c9481c194ae09404
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d6d2a2c3aaa212fd3c2d37f12ed31e4ebbfaee90
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs
@@ -0,0 +1,244 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal enum WeightEditorMode
+    {
+        AddAndSubtract,
+        GrowAndShrink,
+        Smooth
+    }
+
+    internal class WeightEditor
+    {
+        public ISpriteMeshData spriteMeshData
+        {
+            get { return m_SpriteMeshDataController.spriteMeshData; }
+            set { m_SpriteMeshDataController.spriteMeshData = value; }
+        }
+
+        public ICacheUndo cacheUndo { get; set; }
+        public WeightEditorMode mode { get; set; }
+        public int boneIndex { get; set; }
+        public ISelection<int> selection { get; set; }
+        public WeightEditorMode currentMode { get; private set; }
+        public bool useRelativeValues { get; private set; }
+        public bool emptySelectionEditsAll { get; set; }
+        public bool autoNormalize { get; set; }
+
+        private SpriteMeshDataController m_SpriteMeshDataController = new SpriteMeshDataController();
+        private const int maxSmoothIterations = 8;
+        private float[] m_SmoothValues;
+        private readonly List<BoneWeight[]> m_SmoothedBoneWeights = new List<BoneWeight[]>();
+        private readonly List<BoneWeight> m_StoredBoneWeights = new List<BoneWeight>();
+        private int BoneCount
+        {
+            get { return spriteMeshData != null ? spriteMeshData.boneCount : 0; }
+        }
+
+        public WeightEditor()
+        {
+            autoNormalize = true;
+        }
+
+        public void OnEditStart(bool relative)
+        {
+            Validate();
+            
+            RegisterUndo();
+            currentMode = mode;
+            useRelativeValues = relative;
+
+            if (!useRelativeValues)
+                StoreBoneWeights();
+
+            if (mode == WeightEditorMode.Smooth)
+                PrepareSmoothingBuffers();
+        }
+
+        public void OnEditEnd()
+        {
+            Validate();
+
+            if (currentMode == WeightEditorMode.AddAndSubtract)
+            {
+                for (int i = 0; i < spriteMeshData.vertexCount; ++i)
+                    spriteMeshData.GetWeight(i).Clamp(4);
+            }
+
+            if (autoNormalize)
+                m_SpriteMeshDataController.NormalizeWeights(null);
+
+            m_SpriteMeshDataController.SortTrianglesByDepth();
+        }
+
+        public void DoEdit(float value)
+        {
+            Validate();
+
+            if (!useRelativeValues)
+                RestoreBoneWeights();
+
+            if (currentMode == WeightEditorMode.AddAndSubtract)
+                SetWeight(value);
+            else if (currentMode == WeightEditorMode.GrowAndShrink)
+                SetWeight(value, false);
+            else if (currentMode == WeightEditorMode.Smooth)
+                SmoothWeights(value);
+        }
+
+        private void Validate()
+        {
+            if (spriteMeshData == null)
+                throw (new Exception(TextContent.noSpriteSelected));
+        }
+
+        private void RegisterUndo()
+        {
+            Debug.Assert(cacheUndo != null);
+
+            cacheUndo.BeginUndoOperation(TextContent.editWeights);
+        }
+
+        private void SetWeight(float value, bool createNewChannel = true)
+        {
+            if (boneIndex == -1 || spriteMeshData == null)
+                return;
+
+            Debug.Assert(selection != null);
+
+            for (var i = 0; i < spriteMeshData.vertexCount; ++i)
+            {
+                if (selection.Count == 0 && emptySelectionEditsAll ||
+                    selection.Count > 0 && selection.Contains(i))
+                {
+                    var editableBoneWeight = spriteMeshData.GetWeight(i);
+
+                    int channel = editableBoneWeight.GetChannelFromBoneIndex(boneIndex);
+
+                    if (channel == -1)
+                    {
+                        if (createNewChannel && value > 0f)
+                        {
+                            editableBoneWeight.AddChannel(boneIndex, 0f, true);
+                            channel = editableBoneWeight.GetChannelFromBoneIndex(boneIndex);
+                        }
+                        else
+                        {
+                            continue;
+                        }
+                    }
+
+                    editableBoneWeight[channel].weight += value;
+
+                    if (editableBoneWeight.Sum() > 1f)
+                        editableBoneWeight.CompensateOtherChannels(channel);
+
+                    editableBoneWeight.FilterChannels(0f);
+                }
+            }
+        }
+
+        private void SmoothWeights(float value)
+        {
+            Debug.Assert(selection != null);
+
+            for (int i = 0; i < spriteMeshData.vertexCount; ++i)
+            {
+                if (selection.Count == 0 && emptySelectionEditsAll ||
+                    selection.Count > 0 && selection.Contains(i))
+                {
+                    var smoothValue = m_SmoothValues[i];
+
+                    if (smoothValue >= maxSmoothIterations)
+                        continue;
+
+                    m_SmoothValues[i] = Mathf.Clamp(smoothValue + value, 0f, maxSmoothIterations);
+
+                    float lerpValue = GetLerpValue(m_SmoothValues[i]);
+                    int lerpIndex = GetLerpIndex(m_SmoothValues[i]);
+                    BoneWeight[] smoothedBoneWeightsFloor = GetSmoothedBoneWeights(lerpIndex - 1);
+                    BoneWeight[] smoothedBoneWeightsCeil = GetSmoothedBoneWeights(lerpIndex);
+
+                    BoneWeight boneWeight = EditableBoneWeightUtility.Lerp(smoothedBoneWeightsFloor[i], smoothedBoneWeightsCeil[i], lerpValue);
+                    spriteMeshData.GetWeight(i).SetFromBoneWeight(boneWeight);
+                }
+            }
+        }
+
+        protected void PrepareSmoothingBuffers()
+        {
+            if (m_SmoothValues == null || m_SmoothValues.Length != spriteMeshData.vertexCount)
+                m_SmoothValues = new float[spriteMeshData.vertexCount];
+
+            Array.Clear(m_SmoothValues, 0, m_SmoothValues.Length);
+
+            m_SmoothedBoneWeights.Clear();
+
+            BoneWeight[] boneWeights = new BoneWeight[spriteMeshData.vertexCount];
+
+            for (int i = 0; i < spriteMeshData.vertexCount; i++)
+            {
+                EditableBoneWeight editableBoneWeight = spriteMeshData.GetWeight(i);
+                boneWeights[i] = editableBoneWeight.ToBoneWeight(false);
+            }
+
+            m_SmoothedBoneWeights.Add(boneWeights);
+        }
+
+        private BoneWeight[] GetSmoothedBoneWeights(int lerpIndex)
+        {
+            Debug.Assert(lerpIndex >= 0);
+
+            while (lerpIndex >= m_SmoothedBoneWeights.Count && lerpIndex <= maxSmoothIterations)
+            {
+                BoneWeight[] boneWeights;
+                SmoothingUtility.SmoothWeights(m_SmoothedBoneWeights[m_SmoothedBoneWeights.Count - 1], spriteMeshData.indices, BoneCount, out boneWeights);
+                m_SmoothedBoneWeights.Add(boneWeights);
+            }
+
+            return m_SmoothedBoneWeights[Mathf.Min(lerpIndex, maxSmoothIterations)];
+        }
+
+        private float GetLerpValue(float smoothValue)
+        {
+            Debug.Assert(smoothValue >= 0f);
+            return smoothValue - Mathf.Floor(smoothValue);
+        }
+
+        private int GetLerpIndex(float smoothValue)
+        {
+            Debug.Assert(smoothValue >= 0f);
+            return Mathf.RoundToInt(Mathf.Floor(smoothValue) + 1);
+        }
+
+        private void StoreBoneWeights()
+        {
+            Debug.Assert(selection != null);
+
+            m_StoredBoneWeights.Clear();
+
+            for (int i = 0; i < spriteMeshData.vertexCount; i++)
+            {
+                EditableBoneWeight editableBoneWeight = spriteMeshData.GetWeight(i);
+                m_StoredBoneWeights.Add(editableBoneWeight.ToBoneWeight(false));
+            }
+        }
+
+        private void RestoreBoneWeights()
+        {
+            Debug.Assert(selection != null);
+
+            for (int i = 0; i < spriteMeshData.vertexCount; i++)
+            {
+                EditableBoneWeight editableBoneWeight = spriteMeshData.GetWeight(i);
+                editableBoneWeight.SetFromBoneWeight(m_StoredBoneWeights[i]);
+            }
+
+            if (m_SmoothValues != null)
+                Array.Clear(m_SmoothValues, 0, m_SmoothValues.Length);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7943d37aac9e0dcfa869f5181ed21b90d79c3fbb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/SpriteMeshData/WeightEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9df99dfc0f67dd145a0774a4fa06b839
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c0dc3f5959c890e20b652074bddc47042ac83e7b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs
@@ -0,0 +1,19 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class Triangulator : ITriangulator
+    {
+        public void Triangulate(IList<Vector2> vertices, IList<Edge> edges, IList<int> indices)
+        {
+            TriangulationUtility.Triangulate(vertices, edges, indices);
+        }
+
+        public void Tessellate(float minAngle, float maxAngle, float meshAreaFactor, float largestTriangleAreaFactor, int smoothIterations, IList<Vector2> vertices, IList<Edge> edges, IList<int> indices)
+        {
+            TriangulationUtility.Tessellate(minAngle, maxAngle, meshAreaFactor, largestTriangleAreaFactor, smoothIterations, vertices, edges, indices);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..88b7fe051c943f4efdce6eb1173b10c7720a3bc4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Triangulation/Triangulator.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 13c8cc9c7db80f945b93295497790775
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..7d1b86c3f5d43167bd9e214f3da9b472a7707e93
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs
@@ -0,0 +1,72 @@
+using System;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoneInspectorPanel : VisualElement
+    {
+        public class BoneInspectorPanelFactory : UxmlFactory<BoneInspectorPanel, BoneInspectorPanelUxmlTraits> {}
+        public class BoneInspectorPanelUxmlTraits : UxmlTraits {}
+        public event Action<BoneCache, int> onBoneDepthChanged = (bone, depth) => {};
+        public event Action<BoneCache, string> onBoneNameChanged = (bone, name) => {};
+
+        private TextField m_BoneNameField;
+        private IntegerField m_BoneDepthField;
+        
+        public string boneName
+        {
+            get { return m_BoneNameField.value; }
+            set { m_BoneNameField.value = value; }
+        }
+
+        public BoneCache target { get; set; }
+        
+        public int boneDepth
+        {
+            get { return m_BoneDepthField.value; }
+            set { m_BoneDepthField.value = value; }
+        }
+
+        public BoneInspectorPanel()
+        {
+            styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/BoneInspectorPanelStyle.uss"));
+
+            RegisterCallback<MouseDownEvent>((e) => { e.StopPropagation(); });
+            RegisterCallback<MouseUpEvent>((e) => { e.StopPropagation(); });
+        }
+
+        public void BindElements()
+        {
+            m_BoneNameField = this.Q<TextField>("BoneNameField");
+            m_BoneDepthField = this.Q<IntegerField>("BoneDepthField");
+            m_BoneNameField.RegisterCallback<FocusOutEvent>(BoneNameFocusChanged);
+            m_BoneDepthField.RegisterCallback<FocusOutEvent>(BoneDepthFocusChanged);
+        }
+
+        private void BoneNameFocusChanged(FocusOutEvent evt)
+        {
+            onBoneNameChanged(target, boneName);
+        }
+
+        private void BoneDepthFocusChanged(FocusOutEvent evt)
+        {
+            onBoneDepthChanged(target, boneDepth);
+        }
+        public void HidePanel()
+        {
+            // We are hidding the panel, sent any unchanged value
+            this.SetHiddenFromLayout(true);
+            onBoneNameChanged(target, boneName);
+            onBoneDepthChanged(target, boneDepth);
+        }
+        public static BoneInspectorPanel GenerateFromUXML()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/BoneInspectorPanel.uxml");
+            var clone = visualTree.CloneTree().Q<BoneInspectorPanel>("BoneInspectorPanel");
+            clone.BindElements();
+            return clone;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..87d8cfc8fb615e555d471ee232684af530c34666
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/BoneInspectorPanel.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68e86a17b9682ee4a81c0bd5627704a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/MeshToolbar.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/MeshToolbar.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..6d4451e396f279ab11ea4136918c9b73fe66d6ff
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/MeshToolbar.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d3bb77bab9e1a343983ee641d146f99
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..942876e069cee1145d9bc013d2f7729109f9ec0d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs
@@ -0,0 +1,77 @@
+using System;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class PastePanel : VisualElement
+    {
+        public class PastePanelFactory : UxmlFactory<PastePanel, PastePanelUxmlTraits> {}
+        public class PastePanelUxmlTraits : UxmlTraits {}
+
+        public event Action<bool, bool, bool, bool> onPasteActivated = (bones, mesh, flipX, flipY) => {};
+
+        private Toggle m_BonesToggle;
+        private Toggle m_MeshToggle;
+        private Toggle m_FlipXToggle;
+        private Toggle m_FlipYToggle;
+
+        public bool bones
+        {
+            get { return m_BonesToggle.value; }
+            set { m_BonesToggle.value = value; }
+        }
+
+        public bool mesh
+        {
+            get { return m_MeshToggle.value; }
+            set { m_MeshToggle.value = value; }
+        }
+
+        public bool flipX
+        {
+            get { return m_FlipXToggle.value; }
+            set { m_FlipXToggle.value = value; }
+        }
+
+        public bool flipY
+        {
+            get { return m_FlipYToggle.value; }
+            set { m_FlipYToggle.value = value; }
+        }
+
+        public PastePanel()
+        {
+            styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/PastePanelStyle.uss"));
+            if (EditorGUIUtility.isProSkin)
+                AddToClassList("Dark");
+
+            RegisterCallback<MouseDownEvent>((e) => { e.StopPropagation(); });
+            RegisterCallback<MouseUpEvent>((e) => { e.StopPropagation(); });
+        }
+
+        public void BindElements()
+        {
+            m_BonesToggle = this.Q<Toggle>("BonesField");
+            m_MeshToggle = this.Q<Toggle>("MeshField");
+            m_FlipXToggle = this.Q<Toggle>("FlipXField");
+            m_FlipYToggle = this.Q<Toggle>("FlipYField");
+
+            var pasteButton = this.Q<Button>("PasteButton");
+            pasteButton.clickable.clicked += OnPasteActivated;
+        }
+
+        public void OnPasteActivated()
+        {
+            onPasteActivated(bones, mesh, flipX, flipY);
+        }
+
+        public static PastePanel GenerateFromUXML()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/PastePanel.uxml");
+            var clone = visualTree.CloneTree().Q<PastePanel>("PastePanel");
+            clone.BindElements();
+            return clone;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7ba11504d4c2e257eaf3b90500cee3c7563860cc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/PastePanel.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b581e4fda8368f54987b99360c4b24e8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c61af9b73d8554613aace5473248796960a1ef0e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs
@@ -0,0 +1,46 @@
+using UnityEngine;
+using UnityEngine.U2D.Common;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class Toolbar : VisualElement
+    {
+        public class ToolbarFactory : UxmlFactory<Toolbar, ToolbarUxmlTraits> {}
+        public class ToolbarUxmlTraits : UxmlTraits {}
+
+        public Toolbar()
+        {
+            AddToClassList("Toolbar");
+            styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/ToolbarStyle.uss"));
+            if (EditorGUIUtility.isProSkin)
+                AddToClassList("Dark");
+        }
+
+        public void SetButtonChecked(Button toCheck)
+        {
+            var buttons = this.Query<Button>();
+            buttons.ForEach((button) => { button.SetChecked(button == toCheck); });
+        }
+
+        protected void SetButtonChecked(Button button, bool check)
+        {
+            if (button.IsChecked() != check)
+            {
+                if (check)
+                    button.AddToClassList("Checked");
+                else
+                    button.RemoveFromClassList("Checked");
+                button.SetChecked(check);
+            }
+        }
+
+        public void CollapseToolBar(bool collapse)
+        {
+            if (collapse)
+                AddToClassList("Collapse");
+            else
+                RemoveFromClassList("Collapse");
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..efd7d0612c25f86e6297400a49f8ecb7219803ad
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/Toolbar.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26b0ec3fec60ce84eac8ead5fd651199
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/VisualElementExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/VisualElementExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..3344008fdc21414a444dbd0fe9f6c34cfa4575e4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/UI/VisualElementExtensions.cs
@@ -0,0 +1,23 @@
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class VisualElementExtensions
+    {
+        public static void SetHiddenFromLayout(this VisualElement element, bool isHidden)
+        {
+            if (isHidden)
+            {
+                element.SetEnabled(false);
+                element.style.display = DisplayStyle.None;
+                element.style.position = Position.Absolute;
+            }
+            else
+            {
+                element.SetEnabled(true);
+                element.style.display = DisplayStyle.Flex;
+                element.style.position = Position.Relative;
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs
new file mode 100644
index 0000000000000000000000000000000000000000..d9745613d525113e14a7bfd374a7066ea7456e78
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs
@@ -0,0 +1,44 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class UndoScope : IDisposable
+    {
+        private bool m_Disposed;
+        private ICacheUndo m_CacheUndo;
+
+        public UndoScope(ICacheUndo cacheUndo, string operationName, bool incrementGroup)
+        {
+            Debug.Assert(cacheUndo != null);
+
+            if(cacheUndo.isUndoOperationSet == false)
+            {
+                m_CacheUndo = cacheUndo;
+
+                if(incrementGroup)
+                    m_CacheUndo.IncrementCurrentGroup();
+
+                m_CacheUndo.BeginUndoOperation(operationName);
+            }
+        }
+
+        ~UndoScope()
+        {
+            if (!m_Disposed)
+                Debug.LogError("Scope was not disposed! You should use the 'using' keyword or manually call Dispose.");
+        }
+
+        public void Dispose()
+        {
+            if (m_Disposed)
+                return;
+
+            m_Disposed = true;
+            
+            if (m_CacheUndo != null)
+                m_CacheUndo.EndUndoOperation();
+
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..799712803ded1596ead1b6b01261a889e7601be6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UndoScope.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb14a3e61fe4b114ebd94c7d27a6a110
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs
new file mode 100644
index 0000000000000000000000000000000000000000..65ba31bc7b974aa0e9e4cad4a023c30f06ab3155
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs
@@ -0,0 +1,55 @@
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class UnityEngineUndo : IUndo
+    {
+        public void RecordObject(object o, string name)
+        {
+            var obj = o as Object;
+            if (obj != null)
+                Undo.RecordObject(obj, name);
+        }
+
+        public void RegisterCompleteObjectUndo(object o, string name)
+        {
+            var obj = o as Object;
+            if (obj != null)
+                Undo.RegisterCompleteObjectUndo(obj, name);
+        }
+
+        public void RegisterCompleteObjectUndo(object[] o, string name)
+        {
+            var obj = o as Object[];
+            if (obj != null)
+                Undo.RegisterCompleteObjectUndo(obj, name);
+        }
+
+        public void RegisterCreatedObjectUndo(object o, string name)
+        {
+            var obj = o as Object;
+            if (obj != null)
+                Undo.RegisterCreatedObjectUndo(obj, name);
+        }
+
+        public void DestroyObjectImmediate(object o)
+        {
+            var obj = o as Object;
+            if (obj != null)
+                Undo.DestroyObjectImmediate(obj);
+        }
+
+        public void ClearUndo(object o)
+        {
+            var obj = o as Object;
+            if (obj != null)
+                Undo.ClearUndo(obj);
+        }
+
+        public void IncrementCurrentGroup()
+        {
+            Undo.IncrementCurrentGroup();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e83f49e668eece7559035683dcb76342078bb7bd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/Undo/UnityEngineUndo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 609d69ce95fbbe148aac9ed99bf92679
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..00c98909e84c83d09240dc4b692e0b0675d0f613
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs
@@ -0,0 +1,191 @@
+using System;
+using UnityEditor.U2D.Layout;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoneReparentToolController : BoneTreeWidgetController
+    {
+        public BoneReparentToolController(IBoneTreeViewModel model, SkinningEvents eventSystem) : base(model, eventSystem)
+        {}
+
+        public override bool CanDrag()
+        {
+            m_SkinningEvents.boneVisibility.Invoke("drag");
+            return (m_Model.hasCharacter && m_Model.mode == SkinningMode.Character) ||
+                (!m_Model.hasCharacter && m_Model.mode == SkinningMode.SpriteSheet);
+        }
+
+        public override bool CanRename()
+        {
+            m_SkinningEvents.boneVisibility.Invoke("rename");
+            return true;
+        }
+    }
+
+    internal class BoneReparentToolModel : BoneTreeWidgetModel
+    {
+        public BoneReparentToolModel(SkinningCache cache, IBoneVisibilityToolView view)
+        {
+            m_SkinningCache = cache;
+            m_View = view;
+            m_Data = skinningCache.CreateCache<BoneVisibilityToolData>();
+        }
+    }
+
+    internal class BoneReparentTool : SkeletonToolWrapper
+    {
+        BoneReparentToolWindow m_View;
+        BoneReparentToolModel m_Model;
+        private BoneReparentToolController m_Controller;
+
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            if (m_View == null)
+            {
+                m_View = BoneReparentToolWindow.CreateFromUXML();
+            }
+            m_Model = new BoneReparentToolModel(skinningCache, m_View);
+            m_Controller = new BoneReparentToolController(m_Model, skinningCache.events);
+            m_View.GetController = () => m_Controller;
+            m_View.GetModel = () => m_Model;
+            layout.rightOverlay.Add(m_View);
+            m_View.SetHiddenFromLayout(true);
+        }
+
+        protected override void OnActivate()
+        {
+            m_View.SetHiddenFromLayout(false);
+            m_Controller.Activate();
+            skeletonTool.Activate();
+        }
+
+        protected override void OnDeactivate()
+        {
+            m_View.SetHiddenFromLayout(true);
+            m_Controller.Deactivate();
+            skeletonTool.Deactivate();
+        }
+
+        protected override void OnGUI()
+        {
+            skeletonTool.mode = mode;
+            skeletonTool.editBindPose = editBindPose;
+            skeletonTool.DoGUI();
+        }
+    }
+
+    internal class BoneReparentToolWindow : VisualElement, IBoneVisibilityToolView
+    {
+        public class CustomUxmlFactory : UxmlFactory<BoneReparentToolWindow, UxmlTraits> {}
+        BoneReparentToolView m_ToolView;
+        public Func<IBoneTreeViewModel> GetModel = () => null;
+        public Func<BoneTreeWidgetController> GetController = () => null;
+
+        static internal BoneReparentToolWindow CreateFromUXML()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/BoneReparentWindow.uxml");
+            var ve = visualTree.CloneTree().Q("BoneReparentToolWindow") as BoneReparentToolWindow;
+            ve.BindElements();
+            return ve;
+        }
+
+        internal void BindElements()
+        {
+            m_ToolView = this.Q<BoneReparentToolView>();
+            m_ToolView.GetModel = InternalGetModel;
+            m_ToolView.GetController = InternalGetController;
+            this.styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/BoneReparentStyle.uss"));
+        }
+
+        IBoneTreeViewModel InternalGetModel()
+        {
+            return GetModel();
+        }
+
+        BoneTreeWidgetController InternalGetController()
+        {
+            return GetController();
+        }
+
+        public void OnBoneSelectionChange(SkeletonSelection skeleton)
+        {
+            ((IBoneVisibilityToolView)toolView).OnBoneSelectionChange(skeleton);
+        }
+
+        public void OnBoneExpandedChange(BoneCache[] bones)
+        {
+            ((IBoneVisibilityToolView)toolView).OnBoneExpandedChange(bones);
+        }
+
+        public void OnBoneNameChanged(BoneCache bone)
+        {
+            ((IBoneVisibilityToolView)toolView).OnBoneNameChanged(bone);
+        }
+
+        public void OnSelectionChange(SkeletonCache skeleton)
+        {
+            ((IBoneVisibilityToolView)toolView).OnSelectionChange(skeleton);
+        }
+
+        BoneReparentToolView toolView { get {return m_ToolView; } }
+
+        public void Deactivate()
+        {
+            toolView.Deactivate();
+        }
+    }
+
+    internal class BoneReparentToolView : BoneVisibilityToolView
+    {
+        public class CustomUxmlFactory : UxmlFactory<BoneReparentToolView, CustomUxmlTraits> {}
+        public class CustomUxmlTraits : UxmlTraits {}
+
+        protected override VisibilityToolColumnHeader SetupToolColumnHeader()
+        {
+            var columns = new MultiColumnHeaderState.Column[3];
+            columns[0] = new MultiColumnHeaderState.Column
+            {
+                headerContent = VisibilityTreeViewBase.VisibilityIconStyle.visibilityOnIcon,
+                headerTextAlignment = TextAlignment.Center,
+                width = 32,
+                minWidth = 32,
+                maxWidth = 32,
+                autoResize = false,
+                allowToggleVisibility = true
+            };
+            columns[1] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.bone),
+                headerTextAlignment = TextAlignment.Center,
+                width = 130,
+                minWidth = 130,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            
+            columns[2] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.depth),
+                headerTextAlignment = TextAlignment.Center,
+                width = 50,
+                minWidth = 50,
+                maxWidth = 50,
+                autoResize = true,
+                allowToggleVisibility = true
+            };
+            var multiColumnHeaderState = new MultiColumnHeaderState(columns);
+            return new VisibilityToolColumnHeader(multiColumnHeaderState)
+            {
+                GetAllVisibility = GetAllVisibility,
+                SetAllVisibility = SetAllVisibility,
+                canSort = false,
+                height = 20,
+                visibilityColumn = 0
+            };
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c14d534bb129dc3570db35b71f6f83866e26dc15
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneReparentTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a660ba45386a23843a274d00b171e0fc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs
new file mode 100644
index 0000000000000000000000000000000000000000..f7130c80ba2fb4318ce10125e7c5dcb645110451
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs
@@ -0,0 +1,280 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.IMGUI.Controls;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoneTreeWidgetController
+    {
+        protected IBoneTreeViewModel m_Model;
+        protected SkinningEvents m_SkinningEvents;
+
+        public BoneTreeWidgetController(IBoneTreeViewModel model, SkinningEvents eventSystem)
+        {
+            m_Model = model;
+            m_SkinningEvents = eventSystem;
+        }
+
+        public void Activate()
+        {
+            SetupSkeleton();
+
+            m_SkinningEvents.selectedSpriteChanged.AddListener(OnSelectionChange);
+            m_SkinningEvents.skinningModeChanged.AddListener(OnSkinningModuleModeChanged);
+            m_SkinningEvents.boneSelectionChanged.AddListener(OnBoneSelectionChanged);
+            m_SkinningEvents.boneNameChanged.AddListener(OnBoneNameChanged);
+            m_SkinningEvents.skeletonTopologyChanged.AddListener(SkeletonTopologyChanged);
+        }
+
+        public void Deactivate()
+        {
+            m_SkinningEvents.selectedSpriteChanged.RemoveListener(OnSelectionChange);
+            m_SkinningEvents.skinningModeChanged.RemoveListener(OnSkinningModuleModeChanged);
+            m_SkinningEvents.boneSelectionChanged.RemoveListener(OnBoneSelectionChanged);
+            m_SkinningEvents.boneNameChanged.RemoveListener(OnBoneNameChanged);
+            m_SkinningEvents.skeletonTopologyChanged.RemoveListener(SkeletonTopologyChanged);
+            if (m_Model.view != null)
+                m_Model.view.Deactivate();
+        }
+
+        private void OnSelectionChange(SpriteCache sprite)
+        {
+            SetupSkeleton();
+            m_Model.SetAllVisibility(null, true);
+        }
+
+        private void OnBoneSelectionChanged()
+        {
+            m_Model.view.OnBoneSelectionChange(m_Model.GetBoneSelection());
+        }
+
+        private void OnBoneNameChanged(BoneCache bone)
+        {
+            m_Model.view.OnBoneNameChanged(bone);
+        }
+
+        private void OnSkinningModuleModeChanged(SkinningMode mode)
+        {
+            SetupSkeleton();
+            m_Model.SetAllVisibility(null, true);
+        }
+
+        private void SetupSkeleton()
+        {
+            m_Model.view.OnSelectionChange(m_Model.GetSelectedSkeleton());
+            m_Model.view.OnBoneExpandedChange(m_Model.GetExpandedBones());
+            m_Model.view.OnBoneSelectionChange(m_Model.GetBoneSelection());
+        }
+
+        public void SetAllVisibility(bool visibility)
+        {
+            var skeleton = m_Model.GetSelectedSkeleton();
+            if (skeleton != null)
+            {
+                using (m_Model.UndoScope(TextContent.boneVisibility))
+                {
+                    m_Model.SetAllVisibility(skeleton, visibility);
+                }
+            }
+        }
+
+        private void SkeletonTopologyChanged(SkeletonCache skeleton)
+        {
+            m_Model.view.OnSelectionChange(skeleton);
+        }
+
+        public List<TreeViewItem> BuildTreeView()
+        {
+            var rows = new List<TreeViewItem>();
+            var skeleton = m_Model.GetSelectedSkeleton();
+            if (skeleton != null)
+            {
+                var bones = skeleton.bones;
+                var children = bones.Where(x => x.parentBone == null).ToArray();
+                Array.Sort(children, (a, b) => a.siblingIndex.CompareTo(b.siblingIndex));
+
+                foreach (var bone in children)
+                    AddTreeViewItem(rows, bone, bones, 0);
+            }
+            return rows;
+        }
+
+        private static void AddTreeViewItem(IList<TreeViewItem> rows, BoneCache bone, BoneCache[] bones, int depth)
+        {
+            var item = new TreeViewItemBase<BoneCache>(bone.GetInstanceID(), depth, bone.name, bone);
+            rows.Add(item);
+
+            var children = bones.Where(x => x.parentBone == bone).ToArray();
+            Array.Sort(children, (a, b) => a.siblingIndex.CompareTo(b.siblingIndex));
+
+            foreach (var childBone in children)
+                AddTreeViewItem(rows, childBone, bones, depth + 1);
+        }
+
+        public List<int> GetIDsToExpand(BoneCache[] bones)
+        {
+            var result = new List<int>();
+            if (bones != null)
+            {
+                foreach (var bone in bones)
+                {
+                    if (bone != null)
+                    {
+                        var parent = bone.parentBone;
+                        while (parent != null)
+                        {
+                            int parentId = parent.GetInstanceID();
+                            result.Add(parentId);
+                            parent = parent.parentBone;
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+
+        public int[] GetIDsToSelect(BoneCache[] bones)
+        {
+            return bones == null ? new int[0] : Array.ConvertAll(bones, x => x != null ? x.GetInstanceID() : 0);
+        }
+
+        public void SelectBones(IList<int> selectedIds, IList<TreeViewItem> items)
+        {
+            var selectedBones = items.Where(x => selectedIds.Contains(x.id)).Select(y => ((TreeViewItemBase<BoneCache>)y).customData).ToArray();
+            using (m_Model.UndoScope(TextContent.boneSelection))
+            {
+                m_Model.SelectBones(selectedBones);
+                m_SkinningEvents.boneSelectionChanged.Invoke();
+            }
+        }
+
+        public void ExpandBones(IList<int> expandedIds, IList<TreeViewItem> items)
+        {
+            var expandedBones = items.Where(x => expandedIds.Contains(x.id)).Select(y => ((TreeViewItemBase<BoneCache>)y).customData).ToArray();
+            using (m_Model.UndoScope(TextContent.expandBones))
+            {
+                m_Model.SetExpandedBones(expandedBones);
+            }
+        }
+
+        public bool GetTreeItemVisibility(TreeViewItemBase<BoneCache> item)
+        {
+            return m_Model.GetVisibility(item.customData);
+        }
+
+        public void SetTreeItemVisibility(TreeViewItemBase<BoneCache> item, bool visible, bool includeChildren)
+        {
+            var bone = item.customData;
+            if (bone != null && bone.isVisible != visible)
+            {
+                using (m_Model.UndoScope(TextContent.visibilityChange))
+                {
+                    m_Model.SetVisibility(item.customData, visible);
+                    if (includeChildren)
+                    {
+                        // toggle all children as well
+                        SetChildrenVisibility(item, visible);
+                    }
+                }
+            }
+        }
+
+        void SetChildrenVisibility(TreeViewItemBase<BoneCache> bone, bool visible)
+        {
+            if (bone.children == null)
+                return;
+            foreach (var childBone in bone.children)
+            {
+                var cb = childBone as TreeViewItemBase<BoneCache>;
+                SetChildrenVisibility(cb, visible);
+                m_Model.SetVisibility(cb.customData, visible);
+            }
+        }
+
+        public int GetTreeItemDepthValue(TreeViewItemBase<BoneCache> bone)
+        {
+            return m_Model.GetDepth(bone.customData);
+        }
+
+        public void SetTreeItemDepthValue(TreeViewItemBase<BoneCache> bone, int value)
+        {
+            if (bone != null && bone.customData != null)
+            {
+                using (m_Model.UndoScope(TextContent.boneDepth))
+                {
+                    m_Model.SetDepth(bone.customData, value);
+                    m_SkinningEvents.boneNameChanged.Invoke(bone.customData);
+                }
+            }
+        }
+
+        public void SetTreeViewBoneName(IList<TreeViewItem> items, BoneCache bone)
+        {
+            var treeBone = items.FirstOrDefault(x => ((TreeViewItemBase<BoneCache>)x).customData == bone);
+            if (treeBone != null)
+                treeBone.displayName = bone.name;
+        }
+
+        public void TreeViewItemRename(IList<TreeViewItem> rows, int itemID, string newName)
+        {
+            var item = rows.FirstOrDefault(x => x.id == itemID) as TreeViewItemBase<BoneCache>;
+
+            if (item == null)
+                return;
+
+            if (item.customData != null && item.customData.name != newName && !string.IsNullOrEmpty(newName)
+                && !string.IsNullOrWhiteSpace(newName))
+            {
+                item.displayName = newName;
+                using (m_Model.UndoScope(TextContent.boneName))
+                {
+                    m_Model.SetName(item.customData, newName);
+                    m_SkinningEvents.boneNameChanged.Invoke(item.customData);
+                }
+            }
+        }
+
+        public bool CanReparent(TreeViewItemBase<BoneCache> parent, List<TreeViewItem> draggedItems)
+        {
+            TreeViewItemBase<BoneCache> currentParent = parent;
+            while (currentParent != null)
+            {
+                if (draggedItems.Contains(currentParent))
+                    return false;
+                currentParent = currentParent.parent as TreeViewItemBase<BoneCache>;
+            }
+            return true;
+        }
+
+        public void ReparentItems(TreeViewItemBase<BoneCache> newParent, List<TreeViewItem> draggedItems, int insertAtIndex)
+        {
+            if ((m_Model.hasCharacter && m_Model.mode != SkinningMode.Character) ||
+                (!m_Model.hasCharacter && m_Model.mode == SkinningMode.Character))
+                return;
+
+            var parent = newParent != null ? newParent.customData : null;
+            using (m_Model.UndoScope(TextContent.setParentBone))
+            {
+                for (var i = draggedItems.Count - 1; i >= 0; --i)
+                {
+                    var bone = ((TreeViewItemBase<BoneCache>)draggedItems[i]).customData;
+                    m_Model.SetBoneParent(parent, bone, insertAtIndex);
+                    m_SkinningEvents.skeletonTopologyChanged.Invoke(bone.skeleton);
+                }
+            }
+        }
+
+        public virtual bool CanDrag()
+        {
+            m_SkinningEvents.boneVisibility.Invoke("drag");
+            return false;
+        }
+
+        public virtual bool CanRename()
+        {
+            m_SkinningEvents.boneVisibility.Invoke("rename");
+            return false;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e92f4af5bf2143dbeeadce0cc214bf91d834eaf8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewController.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40cebb2c3989f5844a7cbdc20bb68bdf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs
new file mode 100644
index 0000000000000000000000000000000000000000..9fbc542c8b25557d7bf136645076f454900f8938
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs
@@ -0,0 +1,175 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoneVisibilityToolData : CacheObject
+    {
+        [SerializeField]
+        bool m_AllVisibility = true;
+        bool m_PreviousVisibility = true;
+
+        public bool allVisibility
+        {
+            get { return m_AllVisibility; }
+            set { m_AllVisibility = value; }
+        }
+        public bool previousVisiblity
+        {
+            get { return m_PreviousVisibility; }
+            set { m_PreviousVisibility = value; }
+        }
+    }
+
+    internal class BoneTreeWidgetModel : IBoneTreeViewModel
+    {
+        protected SkinningCache m_SkinningCache;
+        protected IBoneVisibilityToolView m_View;
+        protected BoneVisibilityToolData m_Data;
+
+        public SkinningCache skinningCache
+        {
+            get { return m_SkinningCache; }
+        }
+
+        public IBoneVisibilityToolView view
+        {
+            get { return m_View; }
+        }
+
+        public virtual bool GetAllVisibility()
+        {
+            return m_Data.allVisibility;
+        }
+
+        public SkeletonSelection GetBoneSelection()
+        {
+            return skinningCache.skeletonSelection;
+        }
+
+        public BoneCache[] GetExpandedBones()
+        {
+            return skinningCache.GetExpandedBones();
+        }
+
+        public int GetDepth(BoneCache bone)
+        {
+            return (int)bone.depth;
+        }
+
+        public SkeletonCache GetSelectedSkeleton()
+        {
+            return skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite);
+        }
+
+        public bool GetVisibility(BoneCache bone)
+        {
+            return bone.isVisible;
+        }
+
+        public void SelectBones(BoneCache[] bones)
+        {
+            skinningCache.skeletonSelection.elements = bones.ToCharacterIfNeeded();
+        }
+
+        public void SetExpandedBones(BoneCache[] bones)
+        {
+            skinningCache.BoneExpansionChanged(bones);
+        }
+
+        public virtual void SetAllVisibility(SkeletonCache skeleton, bool visibility)
+        {
+            m_Data.allVisibility = visibility;
+            SetAllBoneVisibility(skeleton, visibility);
+            UpdateVisibilityFromPersistentState();
+        }
+
+        public static void SetAllBoneVisibility(SkeletonCache skeleton, bool visibility)
+        {
+            if (skeleton != null)
+            {
+                foreach (var bone in skeleton.bones)
+                    bone.isVisible = visibility;
+            }
+        }
+
+        public void SetBoneParent(BoneCache newParent, BoneCache bone, int insertAtIndex)
+        {
+            TransformCache parent = newParent;
+
+            if (newParent == null)
+                parent = bone.skeleton;
+
+            skinningCache.RestoreBindPose();
+            bone.SetParent(parent, true);
+
+            if (insertAtIndex == -1)
+                insertAtIndex = parent.ChildCount;
+
+            bone.siblingIndex = insertAtIndex;
+            bone.SetDefaultPose();
+        }
+
+        public void SetDepth(BoneCache bone, int depth)
+        {
+            var characterBone = bone.ToCharacterIfNeeded();
+            characterBone.depth = depth;
+            
+            if (characterBone != bone || skinningCache.mode == SkinningMode.Character)
+                skinningCache.SyncSpriteSheetSkeletons();
+
+            skinningCache.events.boneDepthChanged.Invoke(bone);
+        }
+
+        public void SetName(BoneCache bone, string name)
+        {
+            var characterBone = bone.ToCharacterIfNeeded();
+            characterBone.name = name;
+            if (characterBone != bone || skinningCache.mode == SkinningMode.Character)
+            {
+                skinningCache.SyncSpriteSheetSkeletons();
+            }
+        }
+
+        public void SetVisibility(BoneCache bone, bool visibility)
+        {
+            bone.isVisible = visibility;
+            UpdateVisibilityFromPersistentState();
+        }
+
+        public UndoScope UndoScope(string value)
+        {
+            return skinningCache.UndoScope(value);
+        }
+
+        private void UpdateVisibilityFromPersistentState()
+        {
+            skinningCache.BoneVisibilityChanged(GetSelectedSkeleton());
+        }
+
+        public bool hasCharacter {get { return skinningCache.hasCharacter; } }
+        public SkinningMode mode {get { return skinningCache.mode; } }
+    }
+
+
+    internal interface IBoneTreeViewModel
+    {
+        void SetVisibility(BoneCache bone, bool visibility);
+        bool GetVisibility(BoneCache bone);
+        void SetName(BoneCache bone, string name);
+        void SetBoneParent(BoneCache newParent, BoneCache bone, int insertAtIndex);
+        int GetDepth(BoneCache bone);
+        void SetDepth(BoneCache bone, int depth);
+        void SetAllVisibility(SkeletonCache skeleton, bool visibility);
+        bool GetAllVisibility();
+        void SelectBones(BoneCache[] bones);
+        void SetExpandedBones(BoneCache[] bones);
+        IBoneVisibilityToolView view { get; }
+        SkeletonSelection GetBoneSelection();
+        BoneCache[] GetExpandedBones();
+        SkeletonCache GetSelectedSkeleton();
+        bool hasCharacter { get; }
+        SkinningMode mode { get; }
+        UndoScope UndoScope(string value);
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..859d582160301ac3b7ba43781fdf6e4ef00e5100
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneTreeViewModel.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dc4f326c25da1c048a6365f4f5c7198e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c942c793937e7fdddb58ac44be1cd594f2785bde
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs
@@ -0,0 +1,350 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor.IMGUI.Controls;
+using System;
+using System.Linq;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoneVisibilityTool : BoneTreeWidgetModel, IVisibilityTool
+    {
+        private BoneTreeWidgetController m_Controller;
+
+        VisualElement IVisibilityTool.view { get { return (VisualElement)m_View; } }
+        public string name { get { return "Bone"; } }
+        public bool isAvailable
+        {
+            get { return true; }
+        }
+
+        public BoneVisibilityTool(SkinningCache s)
+        {
+            m_SkinningCache = s;
+        }
+
+        public void Setup()
+        {
+            m_Data = skinningCache.CreateCache<BoneVisibilityToolData>();
+            m_Controller = new BoneReparentToolController(this, skinningCache.events);//new BoneTreeWidgetController(this, skinningCache.events);
+            m_View = new BoneReparentToolView()
+            {
+                GetModel = () => this,
+                GetController = () => m_Controller
+            };
+        }
+
+        public void Dispose()
+        {}
+
+        public void Activate()
+        {
+            m_Controller.Activate();
+            if (m_Data.previousVisiblity != m_Data.allVisibility)
+            {
+                m_Data.previousVisiblity = m_Data.allVisibility;
+            }
+        }
+
+        public void Deactivate()
+        {
+            m_Controller.Deactivate();
+        }
+
+        public void SetAvailabilityChangeCallback(Action callback)
+        {}
+    }
+
+
+    internal class BoneVisibilityToolView : VisibilityToolViewBase, IBoneVisibilityToolView
+    {
+        public Func<BoneTreeWidgetController> GetController = () => null;
+        public Func<IBoneTreeViewModel> GetModel = () => null;
+
+        public BoneVisibilityToolView()
+        {
+            m_TreeView = new BoneTreeView(m_TreeViewState, SetupToolColumnHeader())
+            {
+                GetController = InternalGetController
+            };
+            SetupSearchField();
+        }
+
+        protected virtual VisibilityToolColumnHeader SetupToolColumnHeader()
+        {
+            var columns = new MultiColumnHeaderState.Column[2];
+            columns[0] = new MultiColumnHeaderState.Column
+            {
+                headerContent = VisibilityTreeViewBase.VisibilityIconStyle.visibilityOnIcon,
+                headerTextAlignment = TextAlignment.Center,
+                width = 32,
+                minWidth = 32,
+                maxWidth = 32,
+                autoResize = false,
+                allowToggleVisibility = true
+            };
+            columns[1] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.bone),
+                headerTextAlignment = TextAlignment.Center,
+                width = 200,
+                minWidth = 130,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            var multiColumnHeaderState = new MultiColumnHeaderState(columns);
+            return new VisibilityToolColumnHeader(multiColumnHeaderState)
+            {
+                GetAllVisibility = GetAllVisibility,
+                SetAllVisibility = SetAllVisibility,
+                canSort = false,
+                height = 20,
+                visibilityColumn = 0
+            };
+        }
+
+        BoneTreeWidgetController InternalGetController()
+        {
+            return GetController();
+        }
+
+        protected void SetAllVisibility(bool visibility)
+        {
+            GetController().SetAllVisibility(visibility);
+        }
+
+        protected  bool GetAllVisibility()
+        {
+            return GetModel().GetAllVisibility();
+        }
+
+        public void OnSelectionChange(SkeletonCache skeleton)
+        {
+            ((BoneTreeView)m_TreeView).SetupHierarchy();
+        }
+
+        public void OnBoneSelectionChange(SkeletonSelection bones)
+        {
+            ((BoneTreeView)m_TreeView).OnBoneSelectionChanged(bones);
+        }
+
+        public void OnBoneExpandedChange(BoneCache[] bones)
+        {
+            ((BoneTreeView)m_TreeView).OnBoneExpandedChanged(bones);
+        }
+
+        public void OnBoneNameChanged(BoneCache bone)
+        {
+            ((BoneTreeView)m_TreeView).OnBoneNameChanged(bone);
+        }
+
+        public void Deactivate()
+        {
+            if (m_TreeView.HasSelection())
+                m_TreeView.EndRename();
+        }
+    }
+
+    class BoneTreeView : VisibilityTreeViewBase
+    {
+        public Func<BoneTreeWidgetController> GetController = () => null;
+
+        public BoneTreeView(TreeViewState treeViewState, MultiColumnHeader columnHeader)
+            : base(treeViewState, columnHeader)
+        {
+            columnIndexForTreeFoldouts = 1;
+            ReloadView();
+        }
+
+        public void SetupHierarchy()
+        {
+            ReloadView();
+        }
+
+        private void ReloadView()
+        {
+            Reload();
+        }
+
+        public void OnBoneSelectionChanged(SkeletonSelection boneSelection)
+        {
+            var bones = boneSelection.elements.ToSpriteSheetIfNeeded();
+            var ids = GetController().GetIDsToSelect(bones);
+            var result = GetController().GetIDsToExpand(bones);
+            var expandIds = GetExpanded().ToList();
+
+            if (result.Count > 0)
+                expandIds = expandIds.Union(result).ToList();
+            SetExpanded(expandIds);
+            SetSelection(ids);
+        }
+
+        public void OnBoneExpandedChanged(BoneCache[] bones)
+        {
+            var expandIds = GetController().GetIDsToSelect(bones);
+            if (expandIds.Length == 0)
+                return;
+
+            SetExpanded(expandIds.Union(GetExpanded()).ToList());
+        }
+        
+        public void OnBoneNameChanged(BoneCache bone)
+        {
+            GetController().SetTreeViewBoneName(GetRows(), bone);
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            GetController().SelectBones(selectedIds, GetRows());
+        }
+
+        protected override void ExpandedStateChanged()
+        {
+            GetController().ExpandBones(GetExpanded(), GetRows());
+        }
+
+        protected override float GetCustomRowHeight(int row, TreeViewItem item)
+        {
+            return EditorGUIUtility.singleLineHeight * 1.1f;
+        }
+
+        void CellGUI(Rect cellRect, TreeViewItem item, int column, ref RowGUIArgs args)
+        {
+            CenterRectUsingSingleLineHeight(ref cellRect);
+            switch (column)
+            {
+                case 0:
+                    DrawVisibilityCell(cellRect, item);
+                    break;
+                case 1:
+                    DrawNameCell(cellRect, item, ref args);
+                    break;
+                case 2:
+                    DrawDepthCell(cellRect, item);
+                    break;
+            }
+        }
+
+        void DrawDepthCell(Rect cellRect, TreeViewItem item)
+        {
+            var boneItemView = item as TreeViewItemBase<BoneCache>;
+            int depth = GetController().GetTreeItemDepthValue(boneItemView);
+            const int width = 30;
+            cellRect.height = EditorGUIUtility.singleLineHeight;
+            cellRect.x += (cellRect.width - width) * 0.5f;
+            cellRect.width = width;
+            EditorGUI.BeginChangeCheck();
+            depth = EditorGUI.IntField(cellRect, depth);
+            if (EditorGUI.EndChangeCheck())
+                GetController().SetTreeItemDepthValue(boneItemView, depth);
+        }
+
+        void DrawVisibilityCell(Rect cellRect, TreeViewItem item)
+        {
+            GUIStyle style = MultiColumnHeader.DefaultStyles.columnHeaderCenterAligned;
+            EditorGUI.BeginChangeCheck();
+            var boneItemView = item as TreeViewItemBase<BoneCache>;
+            bool visible = GetController().GetTreeItemVisibility(boneItemView);
+            visible = GUI.Toggle(cellRect, visible, visible ? VisibilityIconStyle.visibilityOnIcon : VisibilityIconStyle.visibilityOffIcon, style);
+            if (EditorGUI.EndChangeCheck())
+            {
+                GetController().SetTreeItemVisibility(boneItemView, visible, Event.current.alt);
+            }
+        }
+
+        void DrawNameCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
+        {
+            args.rowRect = cellRect;
+            base.RowGUI(args);
+        }
+
+        protected override Rect GetRenameRect(Rect rowRect, int row, TreeViewItem item)
+        {
+            Rect cellRect = GetCellRectForTreeFoldouts(rowRect);
+            CenterRectUsingSingleLineHeight(ref cellRect);
+            return base.GetRenameRect(cellRect, row, item);
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item;
+
+            for (int i = 0; i < args.GetNumVisibleColumns(); ++i)
+            {
+                CellGUI(args.GetCellRect(i), item, args.GetColumn(i), ref args);
+            }
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem {id = 0, depth = -1, displayName = "Root"};
+            List<TreeViewItem> rows = GetController() != null ? GetController().BuildTreeView() : new List<TreeViewItem>();
+            SetupParentsAndChildrenFromDepths(root, rows);
+            return root;
+        }
+
+        protected override bool CanRename(TreeViewItem item)
+        {
+            return GetController().CanRename();
+        }
+
+        protected override void RenameEnded(RenameEndedArgs args)
+        {
+            var rows = GetRows();
+            GetController().TreeViewItemRename(rows, args.itemID, args.newName);
+            base.RenameEnded(args);
+        }
+
+        // dragging
+        const string k_GenericDragID = "GenericDragColumnDragging";
+        protected override bool CanStartDrag(CanStartDragArgs args)
+        {
+            return true;
+        }
+
+        protected override void SetupDragAndDrop(SetupDragAndDropArgs args)
+        {
+            if (GetController().CanDrag() && !hasSearch)
+            {
+                DragAndDrop.PrepareStartDrag();
+                var draggedRows = GetRows().Where(item => args.draggedItemIDs.Contains(item.id)).ToList();
+                DragAndDrop.SetGenericData(k_GenericDragID, draggedRows);
+                DragAndDrop.objectReferences = new UnityEngine.Object[] {};   // this IS required for dragging to work
+                string title = draggedRows.Count == 1 ? draggedRows[0].displayName : "< Multiple >";
+                DragAndDrop.StartDrag(title);
+            }
+        }
+
+        protected override DragAndDropVisualMode HandleDragAndDrop(DragAndDropArgs args)
+        {
+            // Check if we can handle the current drag data (could be dragged in from other areas/windows in the editor)
+            var draggedRows = DragAndDrop.GetGenericData(k_GenericDragID) as List<TreeViewItem>;
+            if (draggedRows == null)
+                return DragAndDropVisualMode.None;
+
+            // Parent item is null when dragging outside any tree view items.
+            switch (args.dragAndDropPosition)
+            {
+                case DragAndDropPosition.UponItem:
+                case DragAndDropPosition.OutsideItems:
+                case DragAndDropPosition.BetweenItems:
+                {
+                    var newParent = args.parentItem as TreeViewItemBase<BoneCache>;
+                    bool validDrag = false;
+                    validDrag = GetController().CanReparent(newParent, draggedRows);
+                    if (args.performDrop && validDrag)
+                    {
+                        GetController().ReparentItems(newParent, draggedRows, args.insertAtIndex);
+                        Reload();
+                        var selectedIDs = draggedRows.ConvertAll(b => b.id);
+                        SetSelection(selectedIDs, TreeViewSelectionOptions.RevealAndFrame);
+                        SelectionChanged(selectedIDs);
+                    }
+                    return validDrag ? DragAndDropVisualMode.Move : DragAndDropVisualMode.None;
+                }
+            }
+
+            return DragAndDropVisualMode.None;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..84fcfa850740880d5afe5d1ccc0b437756013729
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0e8a5f39ab443849ac34497669e976f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs
new file mode 100644
index 0000000000000000000000000000000000000000..ca6842f5c70fd69aecf36658531bb5c6d9c1d866
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs
@@ -0,0 +1,11 @@
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IBoneVisibilityToolView
+    {
+        void OnBoneSelectionChange(SkeletonSelection skeleton);
+        void OnBoneExpandedChange(BoneCache[] bones);
+        void OnBoneNameChanged(BoneCache bone);
+        void OnSelectionChange(SkeletonCache skeleton);
+        void Deactivate();
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..a5ce697040bd669145c1f0955cbe0d57514d9c92
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/BoneVisibilityToolInterface.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc0f7df10f714e0458bbe6f652412bda
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6a5c62c15df14dcbdd9f849c4f3fc451cbdbd293
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs
@@ -0,0 +1,345 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor.IMGUI.Controls;
+using System;
+using System.Linq;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class MeshVisibilityTool : IVisibilityTool
+    {
+        private MeshVisibilityToolView m_View;
+        private MeshVisibilityToolModel m_Model;
+        private SkinningCache m_SkinningCache;
+        public SkinningCache skinningCache { get { return m_SkinningCache; } }
+
+        public MeshVisibilityTool(SkinningCache s)
+        {
+            m_SkinningCache = s;
+        }
+
+        public void Setup()
+        {
+            m_Model = skinningCache.CreateCache<MeshVisibilityToolModel>();
+            m_View = new MeshVisibilityToolView(skinningCache)
+            {
+                GetModel = () => m_Model,
+                SetAllVisibility = SetAllVisibility,
+                GetAllVisibility = GetAllVisibility
+            };
+        }
+
+        public void Dispose()
+        {
+
+        }
+
+        public VisualElement view { get { return m_View; } }
+        public string name { get { return "Mesh"; } }
+
+        public void Activate()
+        {
+            skinningCache.events.selectedSpriteChanged.AddListener(OnSelectionChange);
+            skinningCache.events.skinningModeChanged.AddListener(OnViewModeChanged);
+            OnViewModeChanged(skinningCache.mode);
+            if (m_Model.previousVisiblity != m_Model.allVisibility)
+            {
+                SetAllMeshVisibility();
+                m_Model.previousVisiblity = m_Model.allVisibility;
+            }
+        }
+
+        public void Deactivate()
+        {
+            skinningCache.events.selectedSpriteChanged.RemoveListener(OnSelectionChange);
+            skinningCache.events.skinningModeChanged.RemoveListener(OnViewModeChanged);
+        }
+
+        public bool isAvailable
+        {
+            get { return false; }
+        }
+
+        public void SetAvailabilityChangeCallback(Action callback)
+        {}
+
+        private void OnViewModeChanged(SkinningMode characterMode)
+        {
+            if (characterMode == SkinningMode.Character)
+            {
+                m_View.Setup(skinningCache.GetSprites());
+            }
+            else
+            {
+                m_View.Setup(new[] { skinningCache.selectedSprite });
+            }
+        }
+
+        private void OnSelectionChange(SpriteCache sprite)
+        {
+            OnViewModeChanged(skinningCache.mode);
+            SetAllMeshVisibility();
+        }
+
+        void SetAllVisibility(bool visibility)
+        {
+            using (skinningCache.UndoScope(TextContent.meshVisibility))
+            {
+                m_Model.allVisibility = visibility;
+                SetAllMeshVisibility();
+            }
+        }
+
+        void SetAllMeshVisibility()
+        {
+            SpriteCache[] sprites;
+            if (skinningCache.mode == SkinningMode.Character)
+                sprites = skinningCache.GetSprites();
+            else
+                sprites = new[] { skinningCache.selectedSprite };
+
+            foreach (var spr in sprites)
+            {
+                if (spr != null)
+                    m_Model.SetMeshVisibility(spr, m_Model.allVisibility);
+            }
+        }
+
+        bool GetAllVisibility()
+        {
+            return m_Model.allVisibility;
+        }
+    }
+
+    internal class MeshVisibilityToolModel : SkinningObject
+    {
+        [SerializeField]
+        bool m_AllVisibility = true;
+        bool m_PreviousVisibility = true;
+
+        public bool allVisibility
+        {
+            get {return m_AllVisibility; }
+            set { m_AllVisibility = value; }
+        }
+
+        public void SetMeshVisibility(SpriteCache sprite, bool visibility)
+        {
+
+        }
+
+        public bool GetMeshVisibility(SpriteCache sprite)
+        {
+            return false;
+        }
+
+        public bool ShouldDisable(SpriteCache sprite)
+        {
+            var mesh = sprite.GetMesh();
+            return mesh == null || mesh.vertices.Count == 0;
+        }
+
+        public bool previousVisiblity
+        {
+            get { return m_PreviousVisibility; }
+            set { m_PreviousVisibility = value; }
+        }
+    }
+
+    internal class MeshVisibilityToolView : VisibilityToolViewBase
+    {
+        public Func<MeshVisibilityToolModel> GetModel = () => null;
+        public Action<bool> SetAllVisibility = (b) => {};
+        public Func<bool> GetAllVisibility = () => true;
+        public SkinningCache skinningCache { get; set; }
+
+        public MeshVisibilityToolView(SkinningCache s)
+        {
+            skinningCache = s;
+            var columns = new MultiColumnHeaderState.Column[2];
+            columns[0] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.name),
+                headerTextAlignment = TextAlignment.Center,
+                width = 200,
+                minWidth = 130,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            columns[1] = new MultiColumnHeaderState.Column
+            {
+                headerContent = new GUIContent(EditorGUIUtility.FindTexture("visibilityOn")),
+                headerTextAlignment = TextAlignment.Center,
+                width = 32,
+                minWidth = 32,
+                maxWidth = 32,
+                autoResize = false,
+                allowToggleVisibility = true
+            };
+            var multiColumnHeaderState = new MultiColumnHeaderState(columns);
+            var multiColumnHeader = new VisibilityToolColumnHeader(multiColumnHeaderState)
+            {
+                GetAllVisibility = InternalGetAllVisibility,
+                SetAllVisibility = InternalSetAllVisibility,
+                canSort = false,
+                height = 20,
+                visibilityColumn = 1
+            };
+            m_TreeView = new MeshTreeView(m_TreeViewState, multiColumnHeader)
+            {
+                GetModel = InternalGetModel
+            };
+            SetupSearchField();
+        }
+
+        MeshVisibilityToolModel InternalGetModel()
+        {
+            return GetModel();
+        }
+
+        public void Setup(SpriteCache[] sprites)
+        {
+            ((MeshTreeView)m_TreeView).Setup(sprites);
+            ((MeshTreeView)m_TreeView).SetSelection(skinningCache.selectedSprite);
+        }
+
+        bool InternalGetAllVisibility()
+        {
+            return GetAllVisibility();
+        }
+
+        void InternalSetAllVisibility(bool visibility)
+        {
+            SetAllVisibility(visibility);
+        }
+    }
+
+    class MeshTreeView : VisibilityTreeViewBase
+    {
+        private List<SpriteCache> m_Sprites = new List<SpriteCache>();
+
+        public MeshTreeView(TreeViewState treeViewState, MultiColumnHeader header)
+            : base(treeViewState, header)
+        {
+            this.showAlternatingRowBackgrounds = true;
+            this.useScrollView = true;
+            Reload();
+        }
+
+        public Func<MeshVisibilityToolModel> GetModel = () => null;
+
+        public void Setup(SpriteCache[] sprites)
+        {
+            m_Sprites.Clear();
+            m_Sprites.AddRange(sprites);
+            Reload();
+        }
+
+        private static TreeViewItem CreateTreeViewItem(SpriteCache part)
+        {
+            return new TreeViewItemBase<SpriteCache>(part.GetInstanceID(), -1, part.name, part);
+        }
+
+        private void AddTreeViewItem(IList<TreeViewItem> rows, SpriteCache part)
+        {
+            if (string.IsNullOrEmpty(searchString) || part.name.IndexOf(searchString, StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                var item = CreateTreeViewItem(part);
+                rows.Add(item);
+                rootItem.AddChild(item);
+            }
+        }
+
+        private void CellGUI(Rect cellRect, TreeViewItem item, int column, ref RowGUIArgs args)
+        {
+            CenterRectUsingSingleLineHeight(ref cellRect);
+            switch (column)
+            {
+                case 0:
+                    DrawNameCell(cellRect, item, ref args);
+                    break;
+                case 1:
+                    DrawVisibilityCell(cellRect, item);
+                    break;
+            }
+        }
+
+        private void DrawVisibilityCell(Rect cellRect, TreeViewItem item)
+        {
+            GUIStyle style = MultiColumnHeader.DefaultStyles.columnHeaderCenterAligned;
+            var itemView = item as TreeViewItemBase<SpriteCache>;
+            var shouldDisable = GetModel().ShouldDisable(itemView.customData);
+            using (new EditorGUI.DisabledScope(shouldDisable))
+            {
+                EditorGUI.BeginChangeCheck();
+                bool visible = GetModel().GetMeshVisibility(itemView.customData);
+                visible = GUI.Toggle(cellRect, visible, visible ? VisibilityIconStyle.visibilityOnIcon : VisibilityIconStyle.visibilityOffIcon, style);
+                if (EditorGUI.EndChangeCheck())
+                    GetModel().SetMeshVisibility(itemView.customData, visible);
+            }
+        }
+
+        private void DrawNameCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
+        {
+            args.rowRect = cellRect;
+            base.RowGUI(args);
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item;
+
+            for (int i = 0; i < args.GetNumVisibleColumns(); ++i)
+            {
+                CellGUI(args.GetCellRect(i), item, args.GetColumn(i), ref args);
+            }
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            SpriteCache newSelected = null;
+            if (selectedIds.Count > 0)
+            {
+                var selected = GetRows().FirstOrDefault(x => ((TreeViewItemBase<SpriteCache>)x).customData.GetInstanceID() == selectedIds[0]) as TreeViewItemBase<SpriteCache>;
+                if (selected != null)
+                    newSelected = selected.customData;
+            }
+
+            var skinningCache = newSelected.skinningCache;
+
+            using (skinningCache.UndoScope(TextContent.selectionChange))
+            {
+                skinningCache.events.selectedSpriteChanged.Invoke(newSelected);
+            }
+        }
+
+        public void SetSelection(SpriteCache sprite)
+        {
+            var rows = GetRows();
+            for (int i = 0; rows != null && i < rows.Count; ++i)
+            {
+                var r = (TreeViewItemBase<SpriteCache>)rows[i];
+                if (r.customData == sprite)
+                {
+                    SetSelection(new[] { r.customData.GetInstanceID() }, TreeViewSelectionOptions.RevealAndFrame);
+                    break;
+                }
+            }
+        }
+
+        protected override IList<TreeViewItem> BuildRows(TreeViewItem root)
+        {
+            var rows = GetRows() ?? new List<TreeViewItem>(200);
+            rows.Clear();
+
+            m_Sprites.RemoveAll(s => s == null);
+
+            foreach (var sprite in m_Sprites)
+                AddTreeViewItem(rows, sprite);
+
+            SetupDepthsFromParentsAndChildren(root);
+            return rows;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..15558272fea0d531fd7de8941ac299b128f8b3cd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/MeshVisibilityTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c86b96101a8b8f043a01b9c64b788b6b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..7f67af52c4eadb0c35617302799260839ec127fb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs
@@ -0,0 +1,1013 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor.IMGUI.Controls;
+using System;
+using System.Linq;
+using UnityEngine.Experimental.U2D.Animation;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface ISpriteVisibilityToolModel
+    {
+        ISpriteVisibilityToolView view { get; }
+        CharacterCache character { get; }
+        bool previousVisibility { get; set; }
+        bool allVisibility { get; set; }
+        SkinningMode mode { get; }
+        bool hasCharacter { get; }
+        UndoScope UndoScope(string description);
+        SpriteCache selectedSprite { get; }
+        SpriteCategoryListCacheObject spriteCategoryList { get; }
+    }
+
+    internal interface ISpriteVisibilityToolView
+    {
+        void Setup();
+        void SetSelection(SpriteCache sprite);
+        void SetSelectionIds(IList<int> selectedIds);
+    }
+
+    internal class SpriteVisibilityToolData : CacheObject
+    {
+        [SerializeField]
+        bool m_AllVisibility = true;
+        bool m_PreviousVisibility = true;
+
+        public bool allVisibility
+        {
+            get { return m_AllVisibility; }
+            set { m_PreviousVisibility = m_AllVisibility = value; }
+        }
+
+        public bool previousVisibility
+        {
+            get { return m_PreviousVisibility; }
+            set { m_PreviousVisibility = value; }
+        }
+    }
+
+    internal class SpriteVisibilityToolController
+    {
+        bool m_UpdateViewOnSelection = true;
+
+        internal interface ISpriteVisibilityItem
+        {
+            bool visibility { get; set; }
+            ICharacterOrder characterOrder { get;}
+        }
+
+        internal class SpriteVisibilityGroupItem : ISpriteVisibilityItem
+        {
+            public CharacterGroupCache group;
+            public ISpriteVisibilityItem[] childItems;
+            bool ISpriteVisibilityItem.visibility
+            {
+                get { return group.isVisible; }
+                set
+                {
+                    if (childItems != null)
+                    {
+                        foreach (var item in childItems)
+                            item.visibility = value;
+                    }
+                    group.isVisible = value;
+                }
+            }
+            
+            public ICharacterOrder characterOrder { get { return group; } }
+        }
+
+        internal class SpriteVisibilitySpriteItem : ISpriteVisibilityItem
+        {
+            public CharacterPartCache sprite;
+            bool ISpriteVisibilityItem.visibility
+            {
+                get { return sprite.isVisible; }
+                set { sprite.isVisible = value; }
+            }
+            public ICharacterOrder characterOrder { get { return sprite; } }
+        }
+
+        ISpriteVisibilityToolModel m_Model;
+        SkinningEvents m_Events;
+        public event Action OnAvailabilityChangeListeners = () => {};
+
+        public SpriteVisibilityToolController(ISpriteVisibilityToolModel model, SkinningEvents events)
+        {
+            m_Model = model;
+            m_Events = events;
+            m_Events.skinningModeChanged.AddListener(OnViewModeChanged);
+        }
+
+        public void Activate()
+        {
+            m_Events.selectedSpriteChanged.AddListener(OnSpriteSelectedChanged);
+            m_Model.view.Setup();
+            m_Model.view.SetSelection(m_Model.selectedSprite);
+            if (m_Model.previousVisibility != m_Model.allVisibility)
+            {
+                SetAllCharacterSpriteVisibility();
+                m_Model.previousVisibility = m_Model.allVisibility;
+            }
+        }
+
+        public void Deactivate()
+        {
+            m_Events.selectedSpriteChanged.RemoveListener(OnSpriteSelectedChanged);
+        }
+
+        public void Dispose()
+        {
+            m_Events.skinningModeChanged.RemoveListener(OnViewModeChanged);
+        }
+
+        void OnViewModeChanged(SkinningMode mode)
+        {
+            OnAvailabilityChangeListeners();
+            if (isAvailable && m_Model.previousVisibility != m_Model.allVisibility)
+                SetAllCharacterSpriteVisibility();
+        }
+
+        private void OnSpriteSelectedChanged(SpriteCache sprite)
+        {
+            if (m_UpdateViewOnSelection)
+                m_Model.view.SetSelection(sprite);
+            m_UpdateViewOnSelection = true;
+        }
+
+        public bool isAvailable
+        {
+            get { return m_Model.mode == SkinningMode.Character; }
+        }
+
+        void SetAllCharacterSpriteVisibility()
+        {
+            if (m_Model.hasCharacter)
+            {
+                using (m_Model.UndoScope(TextContent.spriteVisibility))
+                {
+                    var parts = m_Model.character.parts;
+
+                    foreach (var part in parts)
+                        part.isVisible = m_Model.allVisibility;
+
+                    var groups = m_Model.character.groups;
+                    foreach (var group in groups)
+                        group.isVisible = m_Model.allVisibility;
+                }
+            }
+        }
+
+        public void SetAllVisibility(bool visibility)
+        {
+            using (m_Model.UndoScope(TextContent.spriteVisibility))
+            {
+                m_Model.allVisibility = visibility;
+                SetAllCharacterSpriteVisibility();
+            }
+        }
+
+        public bool GetAllVisibility()
+        {
+            return m_Model.allVisibility;
+        }
+
+        public List<TreeViewItem> BuildTreeView()
+        {
+            var rows = new List<TreeViewItem>();
+            var character = m_Model.character;
+            if (character != null)
+            {
+                var parts = character.parts;
+                var groups = character.groups;
+                var items = CreateTreeGroup(-1, groups, parts, 0);
+                foreach (var item in items)
+                    rows.Add(item);
+                var groupParts = parts.Where(x => x.parentGroup < 0);
+                foreach (var part in groupParts)
+                {
+                    var ii = CreateTreeViewItem(part, groups, 0);
+                    rows.Add(ii);
+                }
+            }
+            rows.Sort((x, y) =>
+            {
+                var x1 = (TreeViewItemBase<ISpriteVisibilityItem>)x;
+                var y1 = (TreeViewItemBase<ISpriteVisibilityItem>)y;
+                return SpriteVisibilityItemOrderSort(x1.customData, y1.customData);
+            });
+            
+            return rows;
+        }
+
+        int SpriteVisibilityItemOrderSort(ISpriteVisibilityItem x, ISpriteVisibilityItem y)
+        {
+            return x.characterOrder.order.CompareTo(y.characterOrder.order);
+        }
+        
+        private List<TreeViewItem> CreateTreeGroup(int level, CharacterGroupCache[] groups, CharacterPartCache[] parts, int depth)
+        {
+            var items = new List<TreeViewItem>();
+            for (int j = 0; j < groups.Length; ++j)
+            {
+                if (groups[j].parentGroup == level)
+                {
+                    var item = new TreeViewItemBase<ISpriteVisibilityItem>(groups[j].GetInstanceID(), depth, groups[j].name, new SpriteVisibilityGroupItem()
+                    {
+                        group = groups[j],
+                    });
+                    items.Add(item);
+                    var children = new List<ISpriteVisibilityItem>();
+                    // find all sprite that has this group
+                    var groupParts = parts.Where(x => x.parentGroup == j);
+                    foreach (var part in groupParts)
+                    {
+                        var ii = CreateTreeViewItem(part, groups, depth + 1);
+                        items.Add(ii);
+                        var visibilityItem = ii as TreeViewItemBase<ISpriteVisibilityItem>;
+                        if (visibilityItem != null)
+                            children.Add(visibilityItem.customData);
+                    }
+
+                    var childItemes = CreateTreeGroup(j, groups, parts, depth + 1);
+                    foreach (var iii in childItemes)
+                    {
+                        items.Add(iii);
+                        var visibilityItem = iii as TreeViewItemBase<ISpriteVisibilityItem>;
+                        if (visibilityItem != null)
+                            children.Add(visibilityItem.customData);
+                    }
+                    (item.customData as SpriteVisibilityGroupItem).childItems = children.ToArray();
+                }
+            }
+            return items;
+        }
+
+        private TreeViewItem CreateTreeViewItem(CharacterPartCache part, CharacterGroupCache[] groups, int depth)
+        {
+            var name = part.sprite.name;
+            return new TreeViewItemBase<ISpriteVisibilityItem>(part.sprite.GetInstanceID(), depth, name,
+                new SpriteVisibilitySpriteItem()
+                {
+                    sprite = part,
+                });
+        }
+
+        public bool GetCharacterPartVisibility(TreeViewItem item)
+        {
+            var i = item as TreeViewItemBase<ISpriteVisibilityItem>;
+            if (i != null)
+                return i.customData.visibility;
+            return false;
+        }
+
+        public void SetCharacterPartVisibility(TreeViewItem item, bool visible, bool isolate)
+        {
+            var i = item as TreeViewItemBase<ISpriteVisibilityItem>;
+            if (i != null)
+            {
+                var characterPart = i.customData;
+                var character = m_Model.character;
+                using (m_Model.UndoScope(TextContent.spriteVisibility))
+                {
+                    if (isolate)
+                    {
+                        foreach (var cpart in character.parts)
+                        {
+                            cpart.isVisible = visible;
+                        }
+                        characterPart.visibility = !visible;
+                    }
+                    else
+                    {
+                        characterPart.visibility = visible;
+                    }
+                }
+            }
+        }
+
+        public void SetSelectedSprite(IList<TreeViewItem> rows, IList<int> selectedIds)
+        {
+            SpriteCache newSelected = null;
+            if (selectedIds.Count > 0)
+            {
+                var selected = rows.FirstOrDefault(x =>
+                {
+                    var item = ((TreeViewItemBase<ISpriteVisibilityItem>)x).customData as SpriteVisibilitySpriteItem;
+                    if (item != null && item.sprite.sprite.GetInstanceID() == selectedIds[0])
+                        return true;
+                    return false;
+                }) as TreeViewItemBase<ISpriteVisibilityItem>;
+                if (selected != null)
+                    newSelected = ((SpriteVisibilitySpriteItem)selected.customData).sprite.sprite;
+            }
+
+            using (m_Model.UndoScope(TextContent.selectionChange))
+            {
+                m_UpdateViewOnSelection = false;
+                m_Events.selectedSpriteChanged.Invoke(newSelected);
+                if (newSelected == null)
+                    m_Model.view.SetSelectionIds(selectedIds);
+            }
+        }
+
+        public int GetTreeViewSelectionID(SpriteCache sprite)
+        {
+            if (sprite != null)
+                return sprite.GetInstanceID();
+            return 0;
+        }
+
+        public SpriteCategory GetCategoryForSprite(TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            var characterPart = customData != null ? customData.sprite : null;
+            if (characterPart != null)
+            {
+                var spriteLib = m_Model.spriteCategoryList;
+                foreach (var category in spriteLib.categories)
+                {
+                    if (category.labels.FindIndex(x => x.spriteId == characterPart.sprite.id) != -1)
+                        return category;
+                }
+            }
+
+            return new SpriteCategory()
+            {
+                name = "",
+                labels = new List<SpriteCategoryLabel>()
+            };
+        }
+
+        public string[] GetCategoryStrings()
+        {
+            return m_Model.spriteCategoryList.categories.Select(x => x.name).ToArray();
+        }
+
+        public string GetSpriteLabelName(SpriteCategory category, TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            var characterPart = customData != null ? customData.sprite : null;
+            var index = -1;
+            if (characterPart != null)
+            {
+                index = category.labels.FindIndex(x => x.spriteId == characterPart.sprite.id);
+            }
+            if (index >= 0)
+                return category.labels[index].name;
+            return "";
+        }
+
+        int GetCategoryIndexForSprite(SpriteCategory category, TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            var characterPart = customData != null ? customData.sprite : null;
+            var index = -1;
+            if (characterPart != null)
+            {
+                index = category.labels.FindIndex(x => x.spriteId == characterPart.sprite.id);
+            }
+            return index;
+        }
+
+        public void RemoveSpriteFromCategory(TreeViewItem treeViewItem)
+        {
+            var spriteLibCategory = GetCategoryForSprite(treeViewItem);
+            var index = GetCategoryIndexForSprite(spriteLibCategory, treeViewItem);
+            if (index >= 0)
+            {
+                var labels = spriteLibCategory.labels.ToList();
+                labels.RemoveAt(index);
+                spriteLibCategory.labels = labels;
+                m_Events.spriteLibraryChanged.Invoke();
+            }
+        }
+
+        public void SetCategoryForSprite(string categoryName, TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var spriteData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            if (spriteData != null)
+            {
+                var category = GetCategoryForSprite(treeViewItem);
+                var labelName = GetSpriteLabelName(category, treeViewItem);
+                if (string.IsNullOrEmpty(labelName))
+                    labelName = spriteData.sprite.sprite.name;
+                SetCategoryForSprite(categoryName, labelName, spriteTreeViewItem.customData);
+            }
+        }
+
+        public void SetCategoryForSprite(string categoryName, string labelName, TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            SetCategoryForSprite(categoryName, labelName, spriteTreeViewItem.customData);
+        }
+
+        void SetCategoryForSprite(string categoryName, string labelName, ISpriteVisibilityItem spriteVisibilityItem)
+        {
+            categoryName = categoryName.Trim();
+            labelName = labelName.Trim();
+            var customData = spriteVisibilityItem as SpriteVisibilitySpriteItem;
+            var characterPart = customData != null ? customData.sprite : null;
+            if (characterPart != null && characterPart.sprite != null)
+            {
+                var spriteLib = m_Model.spriteCategoryList;
+                using (m_Model.UndoScope(TextContent.spriteCategoryChanged))
+                {
+                    spriteLib.AddSpriteToCategory(categoryName, new SpriteCategoryLabel()
+                    {
+                        name = labelName,
+                        spriteId = characterPart.sprite.id
+                    }
+                    );
+                    m_Events.spriteLibraryChanged.Invoke();
+                }
+            }
+        }
+
+        public bool IsLabelDuplicate(SpriteCategory category, string labelName)
+        {
+            var hash = SpriteLibraryAsset.GetStringHash(labelName);
+            return category.labels.Count(x => x.name == labelName || hash == SpriteLibraryAsset.GetStringHash(x.name)) > 1;
+        }
+
+        public void SetCategoryLabelName(string labelname, TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            var characterPart = customData != null ? customData.sprite : null;
+            if (characterPart != null && characterPart.sprite != null)
+            {
+                var spriteLib = m_Model.spriteCategoryList;
+                using (m_Model.UndoScope(TextContent.spriteCategoryIndexChanged))
+                {
+                    spriteLib.ChangeSpriteLabelName(labelname, characterPart.sprite.id);
+                    m_Events.spriteLibraryChanged.Invoke();
+                }
+            }
+        }
+
+        public bool SupportCateogry(TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+            return customData != null;
+        }
+
+        public bool SupportConvertToCatgory(TreeViewItem treeViewItem)
+        {
+            var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+            var customData = spriteTreeViewItem.customData as SpriteVisibilityGroupItem;
+            return customData != null;
+        }
+
+        private bool SupportConvertToCatgory(ISpriteVisibilityItem treeViewItem)
+        {
+            return treeViewItem is SpriteVisibilityGroupItem;
+        }
+
+        private void ConvertLayerToCategory(ISpriteVisibilityItem treeViewItem)
+        {
+            if (SupportConvertToCatgory(treeViewItem))
+            {
+                var groupItem = treeViewItem as SpriteVisibilityGroupItem;
+                foreach (var item in groupItem.childItems)
+                    ConvertLayerToCategory(item);
+            }
+            else
+            {
+                var groupItem = treeViewItem as SpriteVisibilitySpriteItem;
+                var name = groupItem.sprite.sprite.name;
+                SetCategoryForSprite(name, name, groupItem);
+            }
+        }
+
+        public void ClearCategory(TreeViewItem treeViewItem)
+        {
+            if (SupportConvertToCatgory(treeViewItem))
+            {
+                var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+                var customData = spriteTreeViewItem.customData as SpriteVisibilityGroupItem;
+                AddGroupToCategory("", customData);
+            }
+            else
+            {
+                var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+                var item = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+                SetCategoryForSprite("", "", item);
+            }
+        }
+
+        public void ConvertLayerToCategory(TreeViewItem treeViewItem)
+        {
+            if (SupportConvertToCatgory(treeViewItem))
+            {
+                var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+                ConvertLayerToCategory(spriteTreeViewItem.customData);
+            }
+            else
+            {
+                var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+                var groupItem = spriteTreeViewItem.customData as SpriteVisibilitySpriteItem;
+                var name = groupItem.sprite.sprite.name;
+                SetCategoryForSprite(name, name, groupItem);
+            }
+        }
+
+        public void ConvertToCategory(TreeViewItem treeViewItem)
+        {
+            if (SupportConvertToCatgory(treeViewItem))
+            {
+                var spriteTreeViewItem = treeViewItem as TreeViewItemBase<ISpriteVisibilityItem>;
+                var groupItem = spriteTreeViewItem.customData as SpriteVisibilityGroupItem;
+                AddGroupToCategory(groupItem.group.name, groupItem);
+            }
+        }
+
+        void AddGroupToCategory(string categoryName, SpriteVisibilityGroupItem groupItem)
+        {
+            foreach (var item in groupItem.childItems)
+            {
+                if (item is SpriteVisibilityGroupItem)
+                    AddGroupToCategory(categoryName, item as SpriteVisibilityGroupItem);
+                else if (item is SpriteVisibilitySpriteItem)
+                {
+                    var spriteItem = (SpriteVisibilitySpriteItem)item;
+                    SetCategoryForSprite(categoryName, spriteItem.sprite.sprite.name, item);
+                }
+            }
+        }
+
+        public void RemoveUnusedCategory()
+        {
+            var spriteLib = m_Model.spriteCategoryList;
+            var changed = false;
+            for (int i = 0; i < spriteLib.categories.Count; ++i)
+            {
+                if (spriteLib.categories[i].labels.Count == 0)
+                {
+                    spriteLib.categories.RemoveAt(i);
+                    --i;
+                    changed = true;
+                }
+            }
+            if (changed)
+                m_Events.spriteLibraryChanged.Invoke();
+        }
+    }
+
+    internal class SpriteVisibilityTool : IVisibilityTool, ISpriteVisibilityToolModel
+    {
+        SpriteVisibilityToolView m_View;
+        SpriteVisibilityToolController m_Controller;
+
+        private SpriteVisibilityToolData m_Data;
+        private SkinningCache m_SkinningCache;
+        public SkinningCache skinningCache { get { return m_SkinningCache; } }
+
+        public SpriteVisibilityTool(SkinningCache s)
+        {
+            m_SkinningCache = s;
+            m_Data = skinningCache.CreateCache<SpriteVisibilityToolData>();
+            m_Controller = new SpriteVisibilityToolController(this, skinningCache.events);
+            m_View = new SpriteVisibilityToolView()
+            {
+                GetController = () => m_Controller
+            };
+        }
+
+        public void Setup()
+        {}
+
+        public void Dispose()
+        {
+            m_Controller.Dispose();
+        }
+
+        public VisualElement view { get { return m_View; } }
+        public string name { get { return L10n.Tr(TextContent.sprite); } }
+
+        public void Activate()
+        {
+            m_Controller.Activate();
+        }
+
+        public void Deactivate()
+        {
+            m_Controller.Deactivate();
+        }
+
+        public bool isAvailable
+        {
+            get { return m_Controller.isAvailable; }
+        }
+
+
+        public void SetAvailabilityChangeCallback(Action callback)
+        {
+            m_Controller.OnAvailabilityChangeListeners += callback;
+        }
+
+        ISpriteVisibilityToolView ISpriteVisibilityToolModel.view { get {return m_View;} }
+
+        bool ISpriteVisibilityToolModel.hasCharacter { get { return skinningCache.hasCharacter; } }
+        SpriteCache ISpriteVisibilityToolModel.selectedSprite { get { return skinningCache.selectedSprite; } }
+        CharacterCache ISpriteVisibilityToolModel.character { get { return skinningCache.character; } }
+        bool ISpriteVisibilityToolModel.previousVisibility { get { return m_Data.previousVisibility; } set { m_Data.previousVisibility = value; } }
+        bool ISpriteVisibilityToolModel.allVisibility { get { return m_Data.allVisibility; } set { m_Data.allVisibility = value; } }
+        SkinningMode ISpriteVisibilityToolModel.mode { get { return skinningCache.mode; } }
+        SpriteCategoryListCacheObject ISpriteVisibilityToolModel.spriteCategoryList { get { return skinningCache.spriteCategoryList; }}
+
+        UndoScope ISpriteVisibilityToolModel.UndoScope(string description)
+        {
+            return skinningCache.UndoScope(description);
+        }
+    }
+
+    internal class SpriteVisibilityToolView : VisibilityToolViewBase, ISpriteVisibilityToolView
+    {
+        public Func<SpriteVisibilityToolController> GetController = () => null;
+
+        public SpriteVisibilityToolView()
+        {
+            var columns = new MultiColumnHeaderState.Column[4];
+            columns[0] = new MultiColumnHeaderState.Column
+            {
+                headerContent = VisibilityTreeViewBase.VisibilityIconStyle.visibilityOnIcon,
+                headerTextAlignment = TextAlignment.Center,
+                width = 32,
+                minWidth = 32,
+                maxWidth = 32,
+                autoResize = false,
+                allowToggleVisibility = true
+            };
+            columns[1] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.name),
+                headerTextAlignment = TextAlignment.Center,
+                width = 130,
+                minWidth = 100,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            columns[2] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.category),
+                headerTextAlignment = TextAlignment.Center,
+                width = 70,
+                minWidth = 50,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            columns[3] = new MultiColumnHeaderState.Column
+            {
+                headerContent = EditorGUIUtility.TrTextContent(TextContent.label),
+                headerTextAlignment = TextAlignment.Center,
+                width = 50,
+                minWidth = 30,
+                autoResize = true,
+                allowToggleVisibility = false
+            };
+            var multiColumnHeaderState = new MultiColumnHeaderState(columns);
+            var multiColumnHeader = new VisibilityToolColumnHeader(multiColumnHeaderState)
+            {
+                GetAllVisibility = InternalGetAllVisibility,
+                SetAllVisibility = InternalSetAllVisibility,
+                canSort = false,
+                height = 20,
+                visibilityColumn = 0
+            };
+
+            m_TreeView = new SpriteTreeView(m_TreeViewState, multiColumnHeader)
+            {
+                GetController = InternalGetController
+            };
+            SetupSearchField();
+        }
+
+        SpriteVisibilityToolController InternalGetController()
+        {
+            return GetController();
+        }
+
+        bool InternalGetAllVisibility()
+        {
+            return GetController().GetAllVisibility();
+        }
+
+        void InternalSetAllVisibility(bool visibility)
+        {
+            GetController().SetAllVisibility(visibility);
+        }
+
+        public void Setup()
+        {
+            ((SpriteTreeView)m_TreeView).Setup();
+        }
+
+        public void SetSelection(SpriteCache sprite)
+        {
+            ((SpriteTreeView)m_TreeView).SetSelection(sprite);
+        }
+
+        public void SetSelectionIds(IList<int> selectedIds)
+        {
+            ((SpriteTreeView)m_TreeView).SetSelectionIds(selectedIds);
+        }
+    }
+
+    class SpriteTreeView : VisibilityTreeViewBase
+    {
+        public Func<SpriteVisibilityToolController> GetController = () => null;
+        private static int k_CategorySeletionOffset = 4;
+        public GUIStyle m_Style;
+        public GUIContent m_WarningIcon;
+        int m_SpriteCategoryRenameID;
+        static string[] k_DefaultCategoryList = new string[]
+        {
+            TextContent.none,
+            TextContent.newTrailingDots,
+            TextContent.removeEmptyCategory,
+            ""
+        };
+        private TreeViewItem m_CurrentEdittingItem;
+
+        public SpriteTreeView(TreeViewState treeViewState, MultiColumnHeader multiColumnHeader)
+            : base(treeViewState, multiColumnHeader)
+        {
+            columnIndexForTreeFoldouts = 1;
+        }
+
+        void SkinInit()
+        {
+            if (m_Style == null)
+            {
+                GUIStyle foldOut = "IN Foldout";
+                m_Style = new GUIStyle(foldOut);
+                m_Style.stretchWidth = false;
+                m_Style.richText = false;
+                m_Style.border = new RectOffset(-800, -10, 0, -10);
+                m_Style.padding = new RectOffset(11, 16, 2, 2);
+                m_Style.fixedWidth = 0;
+                m_Style.alignment = TextAnchor.MiddleCenter;
+                m_Style.clipping = TextClipping.Clip;
+                m_Style.normal.background = foldOut.onFocused.background;
+                m_Style.normal.scaledBackgrounds = foldOut.onFocused.scaledBackgrounds;
+                m_Style.normal.textColor = foldOut.normal.textColor;
+                m_Style.onNormal.background = m_Style.normal.background;
+                m_Style.onNormal.scaledBackgrounds = m_Style.normal.scaledBackgrounds;
+                m_Style.onNormal.textColor = m_Style.normal.textColor;
+                m_Style.onActive.background = m_Style.normal.background;
+                m_Style.onActive.scaledBackgrounds = m_Style.normal.scaledBackgrounds;
+                m_Style.onActive.textColor = m_Style.normal.textColor;
+                m_Style.active.background = m_Style.normal.background;
+                m_Style.active.scaledBackgrounds = m_Style.normal.scaledBackgrounds;
+                m_Style.active.textColor = m_Style.normal.textColor;
+                m_Style.onFocused.background = m_Style.normal.background;
+                m_Style.onFocused.scaledBackgrounds = m_Style.normal.scaledBackgrounds;
+                m_Style.onFocused.textColor = m_Style.normal.textColor;
+                m_Style.focused.background = m_Style.normal.background;
+                m_Style.focused.scaledBackgrounds = m_Style.normal.scaledBackgrounds;
+                m_Style.focused.textColor = m_Style.normal.textColor;
+                m_WarningIcon = EditorGUIUtility.TrIconContent("console.warnicon.sml", "Duplicate label name found or label hash value clash. Please use a different name");
+                m_SpriteCategoryRenameID = EditorGUIUtility.GetControlID("SpriteCategoryRenameControlId".GetHashCode(), FocusType.Passive);
+            }
+        }
+
+        public void Setup()
+        {
+            Reload();
+        }
+
+        public override void OnGUI(Rect rect)
+        {
+            if (Event.current.type == EventType.Repaint)
+                SkinInit();
+
+            if (Event.current.type == EventType.MouseUp && Event.current.button == 1)
+            {
+                var canCovert = false;
+                foreach (var item in GetRows())
+                {
+                    if (IsSelected(item.id) && GetController().SupportConvertToCatgory(item))
+                    {
+                        canCovert = true;
+                        break;
+                    }
+                }
+                var genericMenu = new GenericMenu();
+                if (canCovert)
+                {
+                    genericMenu.AddItem(new GUIContent(TextContent.convertGroupToCategory), false, ConvertGroupToCategory);
+                }
+                genericMenu.AddItem(new GUIContent(TextContent.convertLayerToCategory), false, ConvertLayerToCategory);
+                genericMenu.AddItem(new GUIContent(TextContent.clearAllCategory), false, ClearAllCategory);
+                genericMenu.ShowAsContext();
+            }
+            base.OnGUI(rect);
+        }
+
+        void ConvertGroupToCategory()
+        {
+            foreach (var item in GetRows())
+            {
+                if (IsSelected(item.id) && GetController().SupportConvertToCatgory(item))
+                {
+                    GetController().ConvertToCategory(item);
+                }
+            }
+        }
+
+        void ClearAllCategory()
+        {
+            foreach (var item in GetRows())
+            {
+                GetController().ClearCategory(item);
+            }
+        }
+
+        void ConvertLayerToCategory()
+        {
+            foreach (var item in GetRows())
+            {
+                if (IsSelected(item.id))
+                {
+                    GetController().ConvertLayerToCategory(item);
+                }
+            }
+        }
+
+        void CellGUI(Rect cellRect, TreeViewItem item, int column, ref RowGUIArgs args)
+        {
+            CenterRectUsingSingleLineHeight(ref cellRect);
+            switch (column)
+            {
+                case 0:
+                    DrawVisibilityCell(cellRect, item);
+                    break;
+                case 1:
+                    DrawNameCell(cellRect, item, ref args);
+                    break;
+                case 2:
+                    DrawCategoryCell(cellRect, item, ref args);
+                    break;
+                case 3:
+                    DrawIndexCell(cellRect, item, ref args);
+                    break;
+            }
+        }
+
+        void DrawVisibilityCell(Rect cellRect, TreeViewItem item)
+        {
+            var style = MultiColumnHeader.DefaultStyles.columnHeaderCenterAligned;
+            var characterPartVisibility = GetController().GetCharacterPartVisibility(item);
+
+            EditorGUI.BeginChangeCheck();
+
+            var visible = GUI.Toggle(cellRect, characterPartVisibility, characterPartVisibility ? VisibilityIconStyle.visibilityOnIcon : VisibilityIconStyle.visibilityOffIcon, style);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                GetController().SetCharacterPartVisibility(item, visible, Event.current.alt);
+            }
+        }
+
+        void DrawNameCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
+        {
+            args.rowRect = cellRect;
+            base.RowGUI(args);
+        }
+
+        void DrawCategoryCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
+        {
+            if (!GetController().SupportCateogry(item))
+                return;
+            if (m_CurrentEdittingItem != item)
+            {
+                List<string> displayedOptions = new List<string>(k_DefaultCategoryList);
+                var allCategoryStrings = GetController().GetCategoryStrings();
+                foreach (var s in allCategoryStrings)
+                    displayedOptions.Add(s);
+                var category = GetController().GetCategoryForSprite(item);
+                var currentSelection = Array.FindIndex(allCategoryStrings, x => x == category.name);
+
+                currentSelection = currentSelection < 0 ? 0 : currentSelection + k_CategorySeletionOffset;
+                EditorGUI.BeginChangeCheck();
+                currentSelection = EditorGUI.Popup(cellRect, currentSelection, displayedOptions.ToArray(), m_Style);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    if (currentSelection == 1)
+                    {
+                        m_CurrentEdittingItem = item;
+                        DrawCategoryNameControl(cellRect, item);
+                    }
+                    else if (currentSelection == 2)
+                    {
+                        GetController().RemoveUnusedCategory();
+                    }
+                    else
+                    {
+                        var realSelectionIndex = currentSelection - k_CategorySeletionOffset;
+                        var categoryName = realSelectionIndex >= 0 ? displayedOptions[currentSelection] : "";
+                        GetController().SetCategoryForSprite(categoryName, item);
+                    }
+                }
+            }
+            else
+            {
+                if (GUIUtility.keyboardControl != m_SpriteCategoryRenameID)
+                    m_CurrentEdittingItem = null;
+                else
+                    DrawCategoryNameControl(cellRect, item);
+            }
+        }
+
+        void DrawCategoryNameControl(Rect cellRect, TreeViewItem item)
+        {
+            EditorGUI.BeginChangeCheck();
+            if (Event.current.type == EventType.Layout)
+            {
+                GUI.SetNextControlName("SpriteCategoryRename");
+                GUI.FocusControl("SpriteCategoryRename");
+            }
+
+            GUIUtility.keyboardControl = m_SpriteCategoryRenameID;
+            string categoryName = EditorGUI.DelayedTextField(cellRect, GUIContent.none, m_SpriteCategoryRenameID, "");
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (Array.FindIndex(k_DefaultCategoryList, x => x == categoryName) == -1)
+                    GetController().SetCategoryForSprite(categoryName, item);
+                m_CurrentEdittingItem = null;
+            }
+        }
+
+        void DrawIndexCell(Rect cellRect, TreeViewItem item, ref RowGUIArgs args)
+        {
+            if (!GetController().SupportCateogry(item))
+                return;
+            var category = GetController().GetCategoryForSprite(item);
+            if (!string.IsNullOrEmpty(category.name))
+            {
+                var labelName = GetController().GetSpriteLabelName(category, item);
+                var isDuplicate = GetController().IsLabelDuplicate(category, labelName);
+                if (isDuplicate)
+                {
+                    GUI.Label(new Rect(cellRect.x, cellRect.y, 20, cellRect.height), m_WarningIcon);
+                    cellRect.x += 20;
+                    cellRect.width -= 20;
+                }
+                EditorGUI.BeginChangeCheck();
+                string newlabelname = EditorGUI.DelayedTextField(cellRect, labelName);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    GetController().SetCategoryLabelName(newlabelname, item);
+                }
+            }
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item;
+
+            for (int i = 0; i < args.GetNumVisibleColumns(); ++i)
+            {
+                CellGUI(args.GetCellRect(i), item, args.GetColumn(i), ref args);
+            }
+        }
+
+        protected override Rect GetRenameRect(Rect rowRect, int row, TreeViewItem item)
+        {
+            Rect cellRect = GetCellRectForTreeFoldouts(rowRect);
+            CenterRectUsingSingleLineHeight(ref cellRect);
+            return base.GetRenameRect(cellRect, row, item);
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem {id = 0, depth = -1, displayName = "Root"};
+            var rows = GetController() != null ? GetController().BuildTreeView() : new List<TreeViewItem>();
+            SetupParentsAndChildrenFromDepths(root, rows);
+            return root;
+        }
+
+        protected override void SelectionChanged(IList<int> selectedIds)
+        {
+            GetController().SetSelectedSprite(GetRows(), selectedIds);
+        }
+
+        public void SetSelectionIds(IList<int> selectedIds)
+        {
+            SetSelection(selectedIds, TreeViewSelectionOptions.RevealAndFrame);
+        }
+
+        public void SetSelection(SpriteCache sprite)
+        {
+            var id = GetController().GetTreeViewSelectionID(sprite);
+            SetSelection(new[] { id }, TreeViewSelectionOptions.RevealAndFrame);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..cca49b95291d243ac835382c681aa6f8ec82fdcc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/SpriteVisibilityTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98caf1503e1ef65468fc96b334fee770
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs
new file mode 100644
index 0000000000000000000000000000000000000000..22892067fb63208aa89ceaba936d4d3bd657679e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs
@@ -0,0 +1,442 @@
+using System;
+using UnityEngine.U2D.Common;
+using UnityEditor.U2D.Layout;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class VisibilityToolWindow : VisualElement, IVisibilityToolWindow
+    {
+        public class CustomUxmlFactory : UxmlFactory<VisibilityToolWindow, UxmlTraits> {}
+
+        VisualElement m_SelectorContainer;
+        VisualElement m_Container;
+        Slider m_BoneOpacitySlider;
+        Slider m_MeshOpacitySlider;
+        private LayoutOverlay m_Layout;
+        
+        List<Button> m_Tabs;
+        int m_CurrentSelectedTab = 0;
+
+        public event Action<float> onBoneOpacitySliderChange = (f) => {};
+        public event Action<float> onMeshOpacitySliderChange = (f) => {};
+        public event Action onBoneOpacitySliderChangeBegin = () => {};
+        public event Action onBoneOpacitySliderChangeEnd = () => {};
+        public event Action onMeshOpacitySliderChangeBegin = () => {};
+        public event Action onMeshOpacitySliderChangeEnd = () => {};
+
+        public static VisibilityToolWindow CreateFromUXML()
+        {
+            var visualTree = ResourceLoader.Load<VisualTreeAsset>("SkinningModule/VisibilityToolWindow.uxml");
+            var ve = visualTree.CloneTree().Q("VisibilityToolWindow") as VisibilityToolWindow;
+            var resizer = ve.Q("Resizer");
+            resizer.AddManipulator(new VisibilityToolResizer());
+            ve.styleSheets.Add(ResourceLoader.Load<StyleSheet>("SkinningModule/VisibilityTool.uss"));
+            if (EditorGUIUtility.isProSkin)
+                ve.AddToClassList("Dark");
+            ve.BindElements();
+            return ve;
+        }
+
+        public void BindElements()
+        {
+            m_SelectorContainer = this.Q("VisibilityToolSelection");
+            m_Container = this.Q("VisibilityToolContainer");
+            m_BoneOpacitySlider = this.Q<Slider>("BoneOpacitySlider");
+            m_BoneOpacitySlider.RegisterValueChangedCallback(OnBoneOpacitySliderValueChangd);
+            m_MeshOpacitySlider = this.Q<Slider>("MeshOpacitySlider");
+            m_MeshOpacitySlider.RegisterValueChangedCallback(OnMeshOpacitySliderValueChangd);
+            RegisterCallback<MouseDownEvent>(OpacityChangeBegin, TrickleDown.TrickleDown);
+            RegisterCallback<MouseCaptureOutEvent>(OpacityChangeEnd, TrickleDown.TrickleDown);
+            // case 1200857 StopPropagation when bubbling up so that main IMGUI doesn't get the event
+            RegisterCallback<MouseDownEvent>(evt => evt.StopPropagation());
+            m_Tabs = new List<Button>();
+            m_SelectorContainer.Clear();
+        }
+
+        public void Initialize(LayoutOverlay layout)
+        {
+            m_Layout = layout;
+            layout.rightOverlay.Add(this);
+            Hide();
+        }
+
+        public void Show()
+        {
+            m_Container.Clear();
+            this.SetHiddenFromLayout(false);
+            m_Layout.VisibilityWindowOn(true);
+        }
+
+        public void Hide()
+        {
+            m_Container.Clear();
+            this.SetHiddenFromLayout(true);
+            m_Layout.VisibilityWindowOn(false);
+        }
+
+        bool IsOpacityTarget(IEventHandler target, VisualElement opacityTarget)
+        {
+            var ve = target as VisualElement;
+            while (ve != null && ve != this)
+            {
+                if (ve == opacityTarget)
+                    return true;
+                ve = ve.parent;
+            }
+            return false;
+        }
+
+        void OpacityChangeBegin(MouseDownEvent evt)
+        {
+            if (IsOpacityTarget(evt.target, m_BoneOpacitySlider))
+                onBoneOpacitySliderChangeBegin();
+            else if (IsOpacityTarget(evt.target, m_MeshOpacitySlider))
+                onMeshOpacitySliderChangeBegin();
+        }
+
+        void OpacityChangeEnd(MouseCaptureOutEvent evt)
+        {
+            if (IsOpacityTarget(evt.target, m_BoneOpacitySlider))
+                onBoneOpacitySliderChangeEnd();
+            else if (IsOpacityTarget(evt.target, m_MeshOpacitySlider))
+                onMeshOpacitySliderChangeEnd();
+        }
+
+        void OnBoneOpacitySliderValueChangd(ChangeEvent<float> evt)
+        {
+            onBoneOpacitySliderChange(evt.newValue);
+        }
+
+        void OnMeshOpacitySliderValueChangd(ChangeEvent<float> evt)
+        {
+            onMeshOpacitySliderChange(evt.newValue);
+        }
+
+        public void SetBoneOpacitySliderValue(float value)
+        {
+            m_BoneOpacitySlider.value = value;
+            m_BoneOpacitySlider.MarkDirtyRepaint();
+        }
+
+        public void SetMeshOpacitySliderValue(float value)
+        {
+            m_MeshOpacitySlider.value = value;
+            m_MeshOpacitySlider.MarkDirtyRepaint();
+        }
+
+        public void AddToolTab(string name, Action onClick)
+        {
+            var tab = new Button()
+            {
+                text = name
+            };
+            tab.AddToClassList("visibilityToolTab");
+            if (EditorGUIUtility.isProSkin)
+                tab.AddToClassList("visibilityToolTabDark");
+            m_SelectorContainer.Add(tab);
+            m_Tabs.Add(tab);
+            tab.clickable.clicked += onClick;
+        }
+
+        public void SetActiveTab(int toolIndex)
+        {
+            if (m_Tabs.Count > toolIndex && toolIndex >= 0)
+            {
+                m_Tabs[m_CurrentSelectedTab].SetChecked(false);
+                m_Tabs[toolIndex].SetChecked(true);
+                m_CurrentSelectedTab = toolIndex;
+            }
+        }
+
+        public void SetContent(VisualElement content)
+        {
+            m_Container.Clear();
+            m_Container.Add(content);
+        }
+
+        public void SetToolAvailable(int toolIndex, bool available)
+        {
+            if (m_Tabs.Count > toolIndex && toolIndex >= 0)
+            {
+                m_Tabs[toolIndex].SetHiddenFromLayout(!available);
+                if (available == false && toolIndex == m_CurrentSelectedTab)
+                    m_Container.Clear();
+            }
+        }
+    }
+
+    internal class VisibilityTool : BaseTool, IVisibilityToolModel
+    {
+        private VisibilityToolWindow m_ToolView;
+
+        private MeshPreviewBehaviour m_MeshPreviewBehaviour = new MeshPreviewBehaviour();
+        public SkeletonTool skeletonTool { set; private get; }
+
+        VisibilityToolController m_Controller;
+        internal override void OnCreate()
+        {
+            m_ToolView = VisibilityToolWindow.CreateFromUXML();
+            m_Controller = new VisibilityToolController(this, new IVisibilityTool[]
+            {
+                new BoneVisibilityTool(skinningCache),
+                new SpriteVisibilityTool(skinningCache)
+            },
+                () => skeletonTool,
+                () => previewBehaviour);
+        }
+
+        public override IMeshPreviewBehaviour previewBehaviour
+        {
+            get { return m_MeshPreviewBehaviour; }
+        }
+
+        public override void Initialize(LayoutOverlay layout)
+        {
+            m_ToolView.Initialize(layout);
+        }
+
+        protected override void OnGUI()
+        {
+            skeletonTool.skeletonStyle = SkeletonStyles.WeightMap;
+            skeletonTool.mode = SkeletonMode.EditPose;
+            skeletonTool.editBindPose = false;
+            skeletonTool.DoGUI();
+        }
+
+        protected override void OnActivate()
+        {
+            m_MeshPreviewBehaviour.showWeightMap = true;
+            m_Controller.Activate();
+        }
+
+        protected override void OnDeactivate()
+        {
+            m_Controller.Deactivate();
+        }
+
+        int IVisibilityToolModel.currentToolIndex
+        {
+            get
+            {
+                return skinningCache.visibililtyToolIndex;
+            }
+            set
+            {
+                skinningCache.visibililtyToolIndex = value;
+            }
+        }
+
+        float IVisibilityToolModel.boneOpacityValue
+        {
+            get
+            {
+                return VisibilityToolSettings.boneOpacity;
+            }
+            set
+            {
+                VisibilityToolSettings.boneOpacity = value;
+            }
+        }
+
+        float IVisibilityToolModel.meshOpacityValue
+        {
+            get
+            {
+                return VisibilityToolSettings.meshOpacity;
+            }
+            set
+            {
+                VisibilityToolSettings.meshOpacity = value;
+            }
+        }
+
+        UndoScope IVisibilityToolModel.UndoScope(string value)
+        {
+            return skinningCache.UndoScope(value);
+        }
+
+        void IVisibilityToolModel.BeginUndoOperation(string value)
+        {
+            skinningCache.BeginUndoOperation(value);
+        }
+
+        IVisibilityToolWindow IVisibilityToolModel.view { get { return m_ToolView;} }
+        SkinningCache IVisibilityToolModel.skinningCache { get { return skinningCache;} }
+    }
+
+    internal interface IVisibilityToolModel
+    {
+        int currentToolIndex { get; set; }
+        float meshOpacityValue { get; set; }
+        float boneOpacityValue { get; set; }
+        UndoScope UndoScope(string value);
+        void BeginUndoOperation(string value);
+        IVisibilityToolWindow view { get; }
+        SkinningCache skinningCache { get; }
+    }
+
+    internal interface IVisibilityToolWindow
+    {
+        void AddToolTab(string name, Action callback);
+        void SetToolAvailable(int i, bool available);
+        void SetBoneOpacitySliderValue(float value);
+        void SetMeshOpacitySliderValue(float value);
+        event Action<float> onBoneOpacitySliderChange;
+        event Action<float> onMeshOpacitySliderChange;
+        event Action onBoneOpacitySliderChangeBegin;
+        event Action onBoneOpacitySliderChangeEnd;
+        event Action onMeshOpacitySliderChangeBegin;
+        event Action onMeshOpacitySliderChangeEnd;
+        void Show();
+        void Hide();
+        void SetActiveTab(int index);
+        void SetContent(VisualElement content);
+    }
+
+    internal class VisibilityToolController
+    {
+        IVisibilityTool[] m_Tools;
+        IVisibilityToolModel m_Model;
+        Func<SkeletonTool> m_SkeletonTool;
+        Func<IMeshPreviewBehaviour> m_MeshPreviewBehaviour;
+        bool m_DeactivateBoneaTool = false;
+        
+        private IVisibilityTool currentTool
+        {
+            get { return m_Model.currentToolIndex == -1 ? null : m_Tools[m_Model.currentToolIndex]; }
+            set { m_Model.currentToolIndex = value == null ? -1 : Array.FindIndex(m_Tools, x => x == value); }
+        }
+
+        private IVisibilityTool defaultTool
+        {
+            get { return Array.Find(m_Tools, t => t.isAvailable); }
+        }
+
+        public VisibilityToolController(IVisibilityToolModel model, IVisibilityTool[] tools, Func<SkeletonTool> skeletonTool = null, Func<IMeshPreviewBehaviour> meshPreviewBehaviour = null)
+        {
+            m_Model = model;
+            m_Tools = tools;
+            for (int i = 0; i < m_Tools.Length; ++i)
+            {
+                int index = i;
+                var tool = m_Tools[i];
+                tool.SetAvailabilityChangeCallback(() => OnToolAvailabilityChange(index));
+                tool.Setup();
+                model.view.AddToolTab(tool.name, () => ActivateToolWithUndo(tool));
+                model.view.SetToolAvailable(i, tool.isAvailable);
+            }
+            m_SkeletonTool = skeletonTool;
+            m_MeshPreviewBehaviour = meshPreviewBehaviour;
+        }
+
+        public void Activate()
+        {
+            m_Model.view.Show();
+
+            if (currentTool == null)
+                currentTool = defaultTool;
+            ActivateTool(currentTool);
+
+            m_Model.view.SetBoneOpacitySliderValue(m_Model.boneOpacityValue);
+            m_Model.view.SetMeshOpacitySliderValue(m_Model.meshOpacityValue);
+            m_Model.view.onBoneOpacitySliderChange -= OnBoneOpacityChange;
+            m_Model.view.onMeshOpacitySliderChange -= OnMeshOpacityChange;
+            m_Model.view.onBoneOpacitySliderChange += OnBoneOpacityChange;
+            m_Model.view.onMeshOpacitySliderChange += OnMeshOpacityChange;
+            m_Model.view.onBoneOpacitySliderChangeBegin -= OnBoneOpacityChangeBegin;
+            m_Model.view.onBoneOpacitySliderChangeBegin += OnBoneOpacityChangeBegin;
+            m_Model.view.onBoneOpacitySliderChangeEnd -= OnBoneOpacityChangeEnd;
+            m_Model.view.onBoneOpacitySliderChangeEnd += OnBoneOpacityChangeEnd;
+            m_Model.view.onMeshOpacitySliderChangeBegin -= OnMeshOpacityChangeBegin;
+            m_Model.view.onMeshOpacitySliderChangeBegin += OnMeshOpacityChangeBegin;
+            m_Model.view.onMeshOpacitySliderChangeEnd -= OnMeshOpacityChangeEnd;
+            m_Model.view.onMeshOpacitySliderChangeEnd += OnMeshOpacityChangeEnd;
+        }
+
+        public void Deactivate()
+        {
+            m_Model.view.Hide();
+
+            if (currentTool != null)
+                currentTool.Deactivate();
+
+            m_Model.view.onBoneOpacitySliderChange -= OnBoneOpacityChange;
+            m_Model.view.onMeshOpacitySliderChange -= OnMeshOpacityChange;
+            m_Model.view.onBoneOpacitySliderChangeBegin -= OnBoneOpacityChangeBegin;
+            m_Model.view.onBoneOpacitySliderChangeEnd -= OnBoneOpacityChangeEnd;
+            m_Model.view.onMeshOpacitySliderChangeBegin -= OnMeshOpacityChangeBegin;
+            m_Model.view.onMeshOpacitySliderChangeEnd -= OnMeshOpacityChangeEnd;
+        }
+
+        void OnBoneOpacityChangeBegin()
+        {
+            if (m_SkeletonTool != null && m_SkeletonTool() != null && !m_SkeletonTool().isActive)
+            {
+                m_SkeletonTool().Activate();
+                m_DeactivateBoneaTool = true;
+            }
+                
+        }
+
+        void OnBoneOpacityChangeEnd()
+        {
+            if (m_SkeletonTool != null && m_SkeletonTool() != null && m_SkeletonTool().isActive && m_DeactivateBoneaTool)
+                m_SkeletonTool().Deactivate();
+        }
+
+        void OnMeshOpacityChangeBegin()
+        {
+            m_Model.skinningCache.events.meshPreviewBehaviourChange.Invoke(m_MeshPreviewBehaviour());
+        }
+
+        void OnMeshOpacityChangeEnd()
+        {
+            m_Model.skinningCache.events.meshPreviewBehaviourChange.Invoke(null);
+        }
+
+        private void OnBoneOpacityChange(float value)
+        {
+            m_Model.boneOpacityValue = value;
+        }
+
+        private void OnMeshOpacityChange(float value)
+        {
+            m_Model.meshOpacityValue = value;
+        }
+
+        private void OnToolAvailabilityChange(int toolIndex)
+        {
+            var toolChanged = m_Tools[toolIndex];
+            m_Model.view.SetToolAvailable(toolIndex, toolChanged.isAvailable);
+            if (toolChanged == currentTool && toolChanged.isAvailable == false)
+                ActivateTool(defaultTool);
+        }
+
+        private void ActivateToolWithUndo(IVisibilityTool tool)
+        {
+            if (currentTool != tool && tool.isAvailable)
+            {
+                m_Model.BeginUndoOperation(TextContent.visibilityTab);
+                ActivateTool(tool);
+            }
+        }
+
+        private void ActivateTool(IVisibilityTool tool)
+        {
+            if (tool.isAvailable == false)
+                return;
+
+            if (currentTool != null)
+                currentTool.Deactivate();
+
+            currentTool = tool;
+            currentTool.Activate();
+
+            m_Model.view.SetActiveTab(m_Model.currentToolIndex);
+            m_Model.view.SetContent(currentTool.view);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..de95eff851bcbbe79151ac0c583a26cb4be73173
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityTool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ad7233a4a9bae914696f0c4fe3c9c8c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c8c344715b4f049d433faa2a6f517aa87fb1bb41
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs
@@ -0,0 +1,124 @@
+using System;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IVisibilityTool
+    {
+        VisualElement view { get; }
+        string name { get; }
+        void Activate();
+        void Deactivate();
+        bool isAvailable { get; }
+        void SetAvailabilityChangeCallback(Action callback);
+        void Setup();
+        void Dispose();
+    }
+
+    internal class VisibilityToolViewBase : VisualElement
+    {
+        IMGUIContainer m_Container;
+        SearchField m_SearchField;
+        protected TreeView m_TreeView;
+        protected TreeViewState m_TreeViewState = new TreeViewState();
+
+        public Action<float> SetOpacityValue = null;
+        public Func<float> GetOpacityValue = null;
+
+        protected static class Styles
+        {
+            public static readonly GUIStyle preLabel = "preLabel";
+            public static readonly GUIStyle preSlider = "preSlider";
+            public static readonly GUIStyle preSliderThumb = "preSliderThumb";
+        }
+
+        public VisibilityToolViewBase()
+        {
+            m_Container = new IMGUIContainer(OnGUI);
+            this.Add(m_Container);
+            m_TreeViewState.searchString = "";
+        }
+
+        protected void SetupSearchField()
+        {
+            m_SearchField = new SearchField();
+            m_SearchField.downOrUpArrowKeyPressed += m_TreeView.SetFocusAndEnsureSelectedItem;
+        }
+
+        void DoSearchField()
+        {
+            m_SearchField.downOrUpArrowKeyPressed += m_TreeView.SetFocusAndEnsureSelectedItem;
+            GUILayout.BeginHorizontal(EditorStyles.toolbar);
+            m_TreeView.searchString = m_SearchField.OnToolbarGUI(m_TreeView.searchString);
+            GUILayout.EndHorizontal();
+        }
+
+        void DoOpacitySlider()
+        {
+            if (GetOpacityValue != null && SetOpacityValue != null)
+            {
+                GUILayout.BeginHorizontal(EditorStyles.toolbar);
+                EditorGUI.BeginChangeCheck();
+                var opacity = GUILayout.HorizontalSlider(GetOpacityValue(), 0, 1, Styles.preSlider, Styles.preSliderThumb);
+                if (EditorGUI.EndChangeCheck())
+                    SetOpacityValue(opacity);
+                GUILayout.EndHorizontal();
+            }
+        }
+
+        void OnGUI()
+        {
+            GUILayout.BeginVertical();
+            DoSearchField();
+            GUILayout.EndVertical();
+            Rect rect = GUILayoutUtility.GetRect(0, 100000, 0, 100000);
+            m_TreeView.OnGUI(rect);
+            DoOpacitySlider();
+        }
+    }
+
+    internal class TreeViewItemBase<T> : TreeViewItem
+    {
+        public T customData;
+
+        public TreeViewItemBase(int id, int depth, string name, T data) : base(id, depth, name)
+        {
+            customData = data;
+        }
+    }
+
+    internal class VisibilityTreeViewBase : TreeView
+    {
+        static internal class VisibilityIconStyle
+        {
+            public static readonly GUIContent visibilityOnIcon  = new GUIContent(IconUtility.LoadIconResource("Visibility_Tool", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr("On"));
+            public static readonly GUIContent visibilityOffIcon = new GUIContent(IconUtility.LoadIconResource("Visibility_Hidded", IconUtility.k_LightIconResourcePath, IconUtility.k_DarkIconResourcePath), L10n.Tr("Off"));
+        }
+
+
+        public VisibilityTreeViewBase(TreeViewState treeViewState, MultiColumnHeader multiColumn)
+            : base(treeViewState, multiColumn)
+        {
+            Init();
+        }
+
+        public VisibilityTreeViewBase(TreeViewState treeViewState)
+            : base(treeViewState)
+        {
+            Init();
+        }
+
+        void Init()
+        {
+            this.showAlternatingRowBackgrounds = true;
+            this.useScrollView = true;
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            return new TreeViewItem { id = 0, depth = -1 };
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e8d9c20e0ac43087f37ef786b01ac44bf882292a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolBase.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 80b572e0f086ba540b44ec45a404263a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5bab577dbb10312f715dec7b5b141cb3116b9461
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs
@@ -0,0 +1,35 @@
+using System;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class VisibilityToolColumnHeader : MultiColumnHeader
+    {
+        public Action<bool> SetAllVisibility = (b) => {};
+        public Func<bool> GetAllVisibility = () => true;
+
+        public VisibilityToolColumnHeader(MultiColumnHeaderState state)
+            : base(state)
+        {
+            visibilityColumn = -1;
+        }
+
+        public int visibilityColumn { private get; set; }
+
+        protected override void ColumnHeaderGUI(MultiColumnHeaderState.Column column, Rect headerRect, int columnIndex)
+        {
+            if (columnIndex == visibilityColumn)
+            {
+                GUIStyle style = DefaultStyles.columnHeaderCenterAligned;
+                EditorGUI.BeginChangeCheck();
+                var visibility = GetAllVisibility();
+                visibility = GUI.Toggle(headerRect, visibility, visibility ? VisibilityTreeViewBase.VisibilityIconStyle.visibilityOnIcon : VisibilityTreeViewBase.VisibilityIconStyle.visibilityOffIcon, style);
+                if (EditorGUI.EndChangeCheck())
+                    SetAllVisibility(visibility);
+            }
+            else
+                base.ColumnHeaderGUI(column, headerRect, columnIndex);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..f47540df3a5e63939d6c584b86fa7920926431af
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolColumnHeader.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 11be01bfe5fde8f419a0ec4a38e1026e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs
new file mode 100644
index 0000000000000000000000000000000000000000..1fa7a6d4d5f9765273f578932df61edbd1650ed1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs
@@ -0,0 +1,87 @@
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.U2D.Layout
+{
+    internal class VisibilityToolResizer : MouseManipulator
+    {
+        private Vector2 m_Start;
+        private VisualElement m_Root;
+        protected bool m_Active;
+        private Rect m_StartPos;
+
+        public VisibilityToolResizer()
+        {
+            activators.Add(new ManipulatorActivationFilter {button = MouseButton.LeftMouse});
+            m_Active = false;
+        }
+
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback<MouseDownEvent>(OnMouseDown);
+            target.RegisterCallback<MouseMoveEvent>(OnMouseMove);
+            target.RegisterCallback<MouseUpEvent>(OnMouseUp);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback<MouseDownEvent>(OnMouseDown);
+            target.UnregisterCallback<MouseMoveEvent>(OnMouseMove);
+            target.UnregisterCallback<MouseUpEvent>(OnMouseUp);
+        }
+
+        protected void OnMouseDown(MouseDownEvent e)
+        {
+            if (m_Active)
+            {
+                e.StopImmediatePropagation();
+                return;
+            }
+
+
+            if (CanStartManipulation(e))
+            {
+                m_Root = target;
+                while (m_Root.parent != null)
+                    m_Root = m_Root.parent;
+                m_Start = target.ChangeCoordinatesTo(m_Root, e.localMousePosition);
+                m_StartPos = target.parent.layout;
+                m_Active = true;
+                target.CaptureMouse();
+                e.StopPropagation();
+            }
+        }
+
+        protected void OnMouseMove(MouseMoveEvent e)
+        {
+            if (m_Active)
+            {
+                var ce = target.parent;
+                Vector2 diff = target.ChangeCoordinatesTo(m_Root, e.localMousePosition) - m_Start;
+                var newSize = new Vector2(m_StartPos.width - diff.x, m_StartPos.height - diff.y);
+                float minWidth = ce.resolvedStyle.minWidth == StyleKeyword.Auto ? 0 : ce.resolvedStyle.minWidth.value;
+                float minHeight = ce.resolvedStyle.minHeight == StyleKeyword.Auto ? 0 : ce.resolvedStyle.minHeight.value;
+                float maxWidth = ce.resolvedStyle.maxWidth == StyleKeyword.None ? float.MaxValue : ce.resolvedStyle.maxWidth.value;
+                float maxHeight = ce.resolvedStyle.maxHeight == StyleKeyword.None ? float.MaxValue : ce.resolvedStyle.maxHeight.value;
+
+                newSize.x = (newSize.x < minWidth) ? minWidth : ((newSize.x > maxWidth) ? maxWidth : newSize.x);
+                newSize.y = (newSize.y < minHeight) ? minHeight : ((newSize.y > maxHeight) ? maxHeight : newSize.y);
+                ce.style.width = newSize.x;
+                e.StopPropagation();
+            }
+        }
+
+        protected void OnMouseUp(MouseUpEvent e)
+        {
+            if (m_Active)
+            {
+                if (CanStopManipulation(e))
+                {
+                    m_Active = false;
+                    target.ReleaseMouse();
+                    e.StopPropagation();
+                }
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..bca0423318dcac0f2da58a5a19f18d29047398b6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/VisibilityTool/VisibilityToolResizer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e28e411d271b90e45894708257ca80fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs
new file mode 100644
index 0000000000000000000000000000000000000000..fe25ddad064f14361d905659ac6c41ca4ef0fa63
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class BoundedBiharmonicWeightsGenerator : IWeightsGenerator
+    {
+        internal static readonly BoneWeight defaultWeight = new BoneWeight() { weight0 = 1 };
+        private const int kNumIterations = -1;
+        private const int kNumSamples = 10;
+        private const float kMinAngle = 20f;
+        private const float kLargestTriangleAreaFactor = 0.25f;
+        private const float kMeshAreaFactor = 0.0015f;
+
+        [DllImport("BoundedBiharmonicWeightsModule")]
+        private static extern int Bbw(int iterations,
+            [In, Out] IntPtr vertices, int vertexCount, int originalVertexCount,
+            [In, Out] IntPtr indices, int indexCount,
+            [In, Out] IntPtr controlPoints, int controlPointsCount,
+            [In, Out] IntPtr boneEdges, int boneEdgesCount,
+            [In, Out] IntPtr pinIndices, int pinIndexCount,
+            [In, Out] IntPtr weights
+            );
+
+        public BoneWeight[] Calculate(Vector2[] vertices, Edge[] edges, Vector2[] controlPoints, Edge[] bones, int[] pins)
+        {
+            var weights = new BoneWeight[vertices.Length];
+
+            for (var i = 0; i < weights.Length; ++i)
+                weights[i] = defaultWeight;
+
+            var indices = new List<int>(vertices.Length);
+            TriangulationUtility.Triangulate(vertices, edges, indices);
+
+            if (indices.Count < 3)
+                return weights;
+
+            var boneSamples = SampleBones(controlPoints, bones, kNumSamples);
+            var verticesList = new List<Vector2>(vertices.Length + controlPoints.Length + boneSamples.Length);
+            var edgesList = new List<Edge>(edges);
+            var indicesList = new List<int>();
+
+            verticesList.AddRange(vertices);
+            verticesList.AddRange(controlPoints);
+            verticesList.AddRange(boneSamples);
+
+            try
+            {
+                TriangulationUtility.Tessellate(kMinAngle, 0f, kMeshAreaFactor, kLargestTriangleAreaFactor, 0, verticesList, edgesList, indicesList);
+            }
+            catch (Exception)
+            {
+                return weights;
+            }
+
+            var tessellatedVertices = verticesList.ToArray();
+            var tessellatedIndices = indicesList.ToArray();
+
+            GCHandle verticesHandle = GCHandle.Alloc(tessellatedVertices, GCHandleType.Pinned);
+            GCHandle indicesHandle = GCHandle.Alloc(tessellatedIndices, GCHandleType.Pinned);
+            GCHandle controlPointsHandle = GCHandle.Alloc(controlPoints, GCHandleType.Pinned);
+            GCHandle bonesHandle = GCHandle.Alloc(bones, GCHandleType.Pinned);
+            GCHandle pinsHandle = GCHandle.Alloc(pins, GCHandleType.Pinned);
+            GCHandle weightsHandle = GCHandle.Alloc(weights, GCHandleType.Pinned);
+
+            Bbw(kNumIterations,
+                verticesHandle.AddrOfPinnedObject(), tessellatedVertices.Length, vertices.Length,
+                indicesHandle.AddrOfPinnedObject(), tessellatedIndices.Length,
+                controlPointsHandle.AddrOfPinnedObject(), controlPoints.Length,
+                bonesHandle.AddrOfPinnedObject(), bones.Length,
+                pinsHandle.AddrOfPinnedObject(), pins.Length,
+                weightsHandle.AddrOfPinnedObject());
+
+            verticesHandle.Free();
+            indicesHandle.Free();
+            controlPointsHandle.Free();
+            bonesHandle.Free();
+            pinsHandle.Free();
+            weightsHandle.Free();
+
+            for (var i = 0; i < weights.Length; ++i)
+            {
+                var weight = weights[i];
+
+                if (weight.Sum() == 0f)
+                    weights[i] = defaultWeight;
+            }
+
+            return weights;
+        }
+
+        public void DebugMesh(ISpriteMeshData spriteMeshData, Vector2[] vertices, Edge[] edges, Vector2[] controlPoints, Edge[] bones, int[] pins)
+        {
+            var boneSamples = SampleBones(controlPoints, bones, kNumSamples);
+            var verticesList = new List<Vector2>(vertices.Length + controlPoints.Length + boneSamples.Length);
+            var edgesList = new List<Edge>(edges);
+            var indicesList = new List<int>();
+
+            verticesList.AddRange(vertices);
+            verticesList.AddRange(controlPoints);
+            verticesList.AddRange(boneSamples);
+
+            TriangulationUtility.Tessellate(kMinAngle, 0f, kMeshAreaFactor, kLargestTriangleAreaFactor, 0, verticesList, edgesList, indicesList);
+
+            spriteMeshData.Clear();
+
+            verticesList.ForEach(v => spriteMeshData.AddVertex(v, new BoneWeight()));
+            spriteMeshData.edges.AddRange(edgesList);
+            spriteMeshData.indices.AddRange(indicesList);
+        }
+
+        private Vector2[] SampleBones(Vector2[] points, Edge[] edges, int numSamples)
+        {
+            Debug.Assert(numSamples > 0);
+
+            var sampledEdges = new List<Vector2>();
+
+            for (var i = 0; i < edges.Length; i++)
+            {
+                var edge = edges[i];
+                var tip = points[edge.index1];
+                var tail = points[edge.index2];
+                var length = (tip - tail).magnitude;
+
+                for (var s = 0; s < numSamples; s++)
+                {
+                    var f = (s + 1f) / (float)(numSamples + 1f);
+                    sampledEdges.Add(f * tail + (1f - f) * tip);
+                }
+            }
+
+            return sampledEdges.ToArray();
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..76d548629e5e973b8d2d2d02361e8fd8ffac75da
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/BoundedBiharmonicWeightsGenerator.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f299983c913b724da97b312e5f58120
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs
new file mode 100644
index 0000000000000000000000000000000000000000..4c7f318acebd65f681d7320f698547a54887ef56
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs
@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IWeightsGenerator
+    {
+        BoneWeight[] Calculate(Vector2[] vertices, Edge[] edges, Vector2[] controlPoints, Edge[] bones, int[] pins);
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5ffac8763747323c65e1ce469c0e267d9e3f4291
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SkinningModule/WeightsGenerator/IWeightsGenerator.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 518b12f30bc1f1649a6c2c03b688eba9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteSelectionWidget.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteSelectionWidget.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..053c5988bae46ccde52e49a02defe7f36cafc0b9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteLib/SpriteSelectionWidget.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4c818720e20ebad4b9d7ba3cc548cdb6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6d555d94c8abedd3e457c55822b7b848dc38416d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs
@@ -0,0 +1,212 @@
+using System.Collections.Generic;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal class SpriteOutlineRenderer
+    {
+        class OutlineRenderTexture
+        {
+            public Texture outlineTexture;
+            public bool dirty;
+        }
+
+        Material m_OutlineMaterial;
+        Material m_BitMaskMaterial;
+        Dictionary<string, OutlineRenderTexture> m_OutlineTextureCache = new Dictionary<string, OutlineRenderTexture>();
+        ISpriteEditorDataProvider m_CurrentDataProvider;
+        SkinningEvents m_EventSystem;
+        ISpriteEditor m_SpriteEditor;
+
+        public SpriteOutlineRenderer(ISpriteEditor spriteEditor, SkinningEvents eventSystem)
+        {
+            m_BitMaskMaterial = new Material(Shader.Find("com.unity3d.animation/SpriteBitmask"));
+            m_BitMaskMaterial.hideFlags = HideFlags.HideAndDontSave;
+            m_OutlineMaterial = new Material(Shader.Find("com.unity3d.animation/SpriteOutline"));
+            m_OutlineMaterial.hideFlags = HideFlags.HideAndDontSave;
+            m_SpriteEditor = spriteEditor;
+            m_EventSystem = eventSystem;
+            m_EventSystem.meshPreviewChanged.AddListener(OnMeshPreviewChanged);
+            m_EventSystem.selectedSpriteChanged.AddListener(OnSelectionChanged);
+            CheckDataProviderChanged();
+        }
+
+        public void Dispose()
+        {
+            if (m_BitMaskMaterial != null)
+                Object.DestroyImmediate(m_BitMaskMaterial);
+            if (m_OutlineMaterial != null)
+                Object.DestroyImmediate(m_OutlineMaterial);
+            m_EventSystem.meshPreviewChanged.RemoveListener(OnMeshPreviewChanged);
+            m_EventSystem.selectedSpriteChanged.RemoveListener(OnSelectionChanged);
+            DestoryTextures();
+        }
+
+        private void OnMeshPreviewChanged(MeshPreviewCache mesh)
+        {
+            AddOrUpdateMaskTexture(mesh.sprite, true);
+        }
+
+        private void OnSelectionChanged(SpriteCache spriteCache)
+        {
+            CheckDataProviderChanged();
+            AddOrUpdateMaskTexture(spriteCache, false);
+        }
+
+        private void DestoryTextures()
+        {
+            if (m_OutlineTextureCache != null)
+            {
+                foreach (var value in m_OutlineTextureCache.Values)
+                {
+                    if (value != null && value.outlineTexture != null)
+                        Texture.DestroyImmediate(value.outlineTexture);
+                }
+                m_OutlineTextureCache.Clear();
+            }
+        }
+
+        private void AddOrUpdateMaskTexture(SpriteCache sprite, bool regenerate)
+        {
+            SpriteCache selectedSprite = null;
+
+            if (sprite != null)
+                selectedSprite = sprite.skinningCache.selectedSprite;
+
+            if (m_OutlineTextureCache != null && sprite != null)
+            {
+                if (!m_OutlineTextureCache.ContainsKey(sprite.id))
+                    m_OutlineTextureCache.Add(sprite.id, new OutlineRenderTexture() {dirty = true});
+
+                var outlineTextureCache = m_OutlineTextureCache[sprite.id];
+                outlineTextureCache.dirty |= regenerate;
+
+                if (sprite == selectedSprite)
+                {
+                    if (outlineTextureCache.dirty || outlineTextureCache.outlineTexture == null)
+                    {
+                        outlineTextureCache.outlineTexture = GenerateOutlineTexture(m_SpriteEditor, sprite, (RenderTexture)outlineTextureCache.outlineTexture);
+                        if (outlineTextureCache.outlineTexture != null)
+                        {
+                            outlineTextureCache.outlineTexture.hideFlags = HideFlags.HideAndDontSave;
+                            outlineTextureCache.dirty = false;
+                        }
+                    }
+                    m_OutlineMaterial.mainTexture = outlineTextureCache.outlineTexture;
+                }
+            }
+        }
+
+        private void CheckDataProviderChanged()
+        {
+            var dp = m_SpriteEditor.GetDataProvider<ISpriteEditorDataProvider>();
+            if (dp != m_CurrentDataProvider)
+            {
+                DestoryTextures();
+                m_OutlineTextureCache.Clear();
+                m_CurrentDataProvider = dp;
+            }
+        }
+
+        internal void RenderSpriteOutline(ISpriteEditor spriteEditor, SpriteCache sprite)
+        {
+            if (sprite == null)
+                return;
+
+            if (Event.current.type == EventType.Repaint)
+            {
+                UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::RenderSpriteOutline");
+                m_OutlineMaterial.SetColor("_OutlineColor", SelectionOutlineSettings.outlineColor);
+                m_OutlineMaterial.SetFloat("_AdjustLinearForGamma", PlayerSettings.colorSpace == ColorSpace.Linear ? 1.0f : 0.0f);
+                var texture = spriteEditor.GetDataProvider<ITextureDataProvider>().texture;
+                float outlineSize = Mathf.Max(texture.width, texture.height) * SelectionOutlineSettings.selectedSpriteOutlineSize / 1024.0f;
+                m_OutlineMaterial.SetFloat("_OutlineSize", outlineSize);
+                var mesh = GetMesh(sprite);
+                m_OutlineMaterial.SetPass(0);
+                GL.PushMatrix();
+                GL.MultMatrix(Handles.matrix * sprite.GetLocalToWorldMatrixFromMode());
+
+                Rect r = new Rect(mesh.bounds.min.x, mesh.bounds.min.y, mesh.bounds.size.x, mesh.bounds.size.y);
+                GL.Begin(GL.QUADS);
+                GL.Color(Color.white);
+                GL.TexCoord(new Vector3(0, 0, 0));
+                GL.Vertex3(r.xMin, r.yMin, 0);
+
+                GL.TexCoord(new Vector3(1, 0, 0));
+                GL.Vertex3(r.xMax, r.yMin, 0);
+
+                GL.TexCoord(new Vector3(1, 1, 0));
+                GL.Vertex3(r.xMax, r.yMax, 0);
+
+                GL.TexCoord(new Vector3(0, 1, 0));
+                GL.Vertex3(r.xMin, r.yMax, 0);
+                GL.End();
+                GL.PopMatrix();
+                UnityEngine.Profiling.Profiler.EndSample();
+            }
+        }
+
+        private Texture GenerateOutlineTexture(ISpriteEditor spriteEditor, SpriteCache spriteCache, RenderTexture reuseRT)
+        {
+            if (spriteCache != null && spriteCache.textureRect.width != 0 && spriteCache.textureRect.height != 0)
+            {
+                UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::GenerateOutlineTexture");
+                var mesh = GetMesh(spriteCache);
+                var b = mesh.bounds;
+
+                if (reuseRT == null)
+                {
+                    UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::CreateRTNew");
+                    reuseRT = new RenderTexture((int)b.size.x, (int)b.size.y, 24, RenderTextureFormat.ARGBHalf);
+                    UnityEngine.Profiling.Profiler.EndSample();
+                }
+                else if (reuseRT.width != (int)b.size.x || reuseRT.height != (int)b.size.y)
+                {
+                    UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::CreateRTReuse");
+                    Object.DestroyImmediate(reuseRT);
+                    reuseRT = new RenderTexture((int)b.size.x, (int)b.size.y, 24, RenderTextureFormat.ARGBHalf);
+                    UnityEngine.Profiling.Profiler.EndSample();
+                }
+                m_BitMaskMaterial.mainTexture = spriteEditor.GetDataProvider<ITextureDataProvider>().texture;
+
+                var oldRT = RenderTexture.active;
+                Graphics.SetRenderTarget(reuseRT);
+                m_BitMaskMaterial.SetPass(0);
+                UnityEngine.Profiling.Profiler.BeginSample("SpriteOutlineRenderer::DrawMesh");
+                GL.Clear(false, true, new Color(0, 0, 0, 0));
+                GL.PushMatrix();
+                GL.LoadOrtho();
+                var h = b.size.y * 0.5f;
+                var w = h * (b.size.x / b.size.y);
+                GL.LoadProjectionMatrix(Matrix4x4.Ortho(-w, w, -h, h, -1, 1));
+                GL.Begin(GL.QUADS);
+                GL.Color(Color.white);
+                Graphics.DrawMeshNow(mesh, Matrix4x4.Translate(-b.center));
+                GL.End();
+                GL.PopMatrix();
+                Graphics.SetRenderTarget(oldRT);
+                UnityEngine.Profiling.Profiler.EndSample();
+
+                UnityEngine.Profiling.Profiler.EndSample();
+                return reuseRT;
+            }
+
+            return null;
+        }
+
+        private Mesh GetMesh(SpriteCache sprite)
+        {
+            var meshPreview = sprite.GetMeshPreview();
+            var skeleton = sprite.skinningCache.GetEffectiveSkeleton(sprite);
+
+            Debug.Assert(meshPreview != null);
+            Debug.Assert(skeleton != null);
+
+            if (meshPreview.canSkin && skeleton.isPosePreview)
+                return meshPreview.mesh;
+
+            return meshPreview.defaultMesh;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..aa565fed32c8b7621f139b337c46f255bb3dd908
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteOutlineRenderer/SpriteOutlineRenderer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c2c0fb0c74cf78d4a9e0138173ed725b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs
new file mode 100644
index 0000000000000000000000000000000000000000..951865949cfbb1754825e42d2e6ba99a96d5012b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs
@@ -0,0 +1,470 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.U2D;
+using UnityEngine.U2D.Animation;
+using UnityEngine.U2D.Common;
+
+namespace UnityEditor.U2D.Animation
+{
+    //Make sure Bone Gizmo registers callbacks before anyone else
+    [InitializeOnLoad]
+    internal class BoneGizmoInitializer
+    {
+        static BoneGizmoInitializer()
+        {
+            BoneGizmo.instance.Initialize();
+        }
+    }
+
+    internal class BoneGizmo : ScriptableSingleton<BoneGizmo>
+    {
+        private BoneGizmoController m_BoneGizmoController;
+
+        internal BoneGizmoController boneGizmoController { get { return m_BoneGizmoController; } }
+
+        internal void Initialize()
+        {
+            m_BoneGizmoController = new BoneGizmoController(new SkeletonView(new GUIWrapper()), new UnityEngineUndo(), new BoneGizmoToggle());
+            RegisterCallbacks();
+        }
+
+        internal void ClearSpriteBoneCache()
+        {
+            boneGizmoController.ClearSpriteBoneCache();
+        }
+
+        private void RegisterCallbacks()
+        {
+            Selection.selectionChanged += OnSelectionChanged;
+            SceneView.duringSceneGui += OnSceneGUI;
+            AssemblyReloadEvents.afterAssemblyReload += OnAfterAssemblyReload;
+            EditorApplication.playModeStateChanged += PlayModeStateChanged;
+        }
+
+        private void OnSceneGUI(SceneView sceneView)
+        {
+            boneGizmoController.OnGUI();
+        }
+
+        private void OnSelectionChanged()
+        {
+            boneGizmoController.OnSelectionChanged();
+        }
+
+        private void OnAfterAssemblyReload()
+        {
+            boneGizmoController.OnSelectionChanged();
+        }
+
+        private void PlayModeStateChanged(PlayModeStateChange stateChange)
+        {
+            if (stateChange == PlayModeStateChange.EnteredPlayMode ||
+                stateChange == PlayModeStateChange.EnteredEditMode)
+                boneGizmoController.OnSelectionChanged();
+        }
+    }
+
+    internal class BoneGizmoController
+    {
+        private Dictionary<Sprite, UnityEngine.U2D.SpriteBone[]> m_SpriteBones = new Dictionary<Sprite, UnityEngine.U2D.SpriteBone[]>();
+        private Dictionary<Transform, Vector2> m_BoneData = new Dictionary<Transform, Vector2>();
+        private HashSet<SpriteSkin> m_SkinComponents = new HashSet<SpriteSkin>();
+        private HashSet<Transform> m_CachedBones = new HashSet<Transform>();
+        private HashSet<Transform> m_SelectionRoots = new HashSet<Transform>();
+        private ISkeletonView view;
+        private IUndo m_Undo;
+        private Tool m_PreviousTool = Tool.None;
+        private IBoneGizmoToggle m_BoneGizmoToggle;
+        
+        internal IBoneGizmoToggle boneGizmoToggle { get { return m_BoneGizmoToggle; } set { m_BoneGizmoToggle = value; } }
+
+        public Transform hoveredBone
+        {
+            get { return GetBone(view.hoveredBoneID); }
+        }
+        public Transform hoveredTail
+        {
+            get { return GetBone(view.hoveredTailID); }
+        }
+        public Transform hoveredBody
+        {
+            get { return GetBone(view.hoveredBodyID); }
+        }
+        public Transform hoveredJoint
+        {
+            get { return GetBone(view.hoveredJointID); }
+        }
+        public Transform hotBone
+        {
+            get { return GetBone(view.hotBoneID); }
+        }
+
+        private Transform GetBone(int instanceID)
+        {
+            return EditorUtility.InstanceIDToObject(instanceID) as Transform;
+        }
+
+        public BoneGizmoController(ISkeletonView view, IUndo undo, IBoneGizmoToggle toggle)
+        {
+            this.view = view;
+            view.mode = SkeletonMode.EditPose;
+            view.InvalidID = 0;
+            m_Undo = undo;
+            m_BoneGizmoToggle = toggle;
+        }
+
+        internal void OnSelectionChanged()
+        {
+            m_SelectionRoots.Clear();
+
+            foreach (var selectedTransform in Selection.transforms)
+            {
+                var prefabRoot = PrefabUtility.GetOutermostPrefabInstanceRoot(selectedTransform.gameObject);
+                var animator = default(Animator);
+
+                if (prefabRoot != null)
+                    m_SelectionRoots.Add(prefabRoot.transform);
+                else if ((animator = selectedTransform.GetComponentInParent<Animator>()) != null)
+                    m_SelectionRoots.Add(animator.transform);
+                else
+                    m_SelectionRoots.Add(selectedTransform.root);
+            }
+
+            if (m_PreviousTool == Tool.None && Selection.activeTransform != null && m_BoneData.ContainsKey(Selection.activeTransform))
+            {
+                m_PreviousTool = UnityEditor.Tools.current;
+                UnityEditor.Tools.current = Tool.None;
+            }
+
+            if (m_PreviousTool != Tool.None && (Selection.activeTransform == null || !m_BoneData.ContainsKey(Selection.activeTransform)))
+            {
+                if (UnityEditor.Tools.current == Tool.None)
+                    UnityEditor.Tools.current = m_PreviousTool;
+
+                m_PreviousTool = Tool.None;
+            }
+
+            FindSkinComponents();
+        }
+
+        internal void OnGUI()
+        {
+            m_BoneGizmoToggle.OnGUI();
+
+            if (!m_BoneGizmoToggle.enableGizmos)
+                return;
+            
+            PrepareBones();
+            DoBoneGUI();
+        }
+
+        internal void FindSkinComponents()
+        {
+            m_SkinComponents.Clear();
+            
+            foreach (var root in m_SelectionRoots)
+            {
+                var components = root.GetComponentsInChildren<SpriteSkin>(false);
+
+                foreach (var component in components)
+                    m_SkinComponents.Add(component);
+            }
+
+            SceneView.RepaintAll();
+        }
+
+        internal void ClearSpriteBoneCache()
+        {
+            m_SpriteBones.Clear();
+        }
+
+        private void PrepareBones()
+        {
+            if (!view.CanLayout())
+                return;
+
+            if (view.IsActionHot(SkeletonAction.None))
+                m_CachedBones.Clear();
+
+            m_BoneData.Clear();
+
+            foreach (var skinComponent in m_SkinComponents)
+            {
+                if (skinComponent == null)
+                    continue;
+
+                PrepareBones(skinComponent);
+            }
+        }
+
+        private UnityEngine.U2D.SpriteBone[] GetSpriteBones(SpriteSkin spriteSkin)
+        {
+            Debug.Assert(spriteSkin.isValid);
+
+            var sprite = spriteSkin.spriteRenderer.sprite;
+            UnityEngine.U2D.SpriteBone[] spriteBones;
+            if (!m_SpriteBones.TryGetValue(sprite, out spriteBones))
+            {
+                spriteBones = sprite.GetBones();
+                m_SpriteBones[sprite] = sprite.GetBones();
+            }
+            
+            return spriteBones;
+        }
+
+        private void PrepareBones(SpriteSkin spriteSkin)
+        {
+            Debug.Assert(spriteSkin != null);
+            Debug.Assert(view.CanLayout());
+
+            if (!spriteSkin.isActiveAndEnabled || !spriteSkin.isValid || !spriteSkin.spriteRenderer.enabled)
+                return;
+
+            var sprite = spriteSkin.spriteRenderer.sprite;
+            var boneTransforms = spriteSkin.boneTransforms;
+            var spriteBones = GetSpriteBones(spriteSkin);
+            var alpha = 1f;
+
+            if (spriteBones == null)
+                return;
+            
+            for (int i = 0; i < boneTransforms.Length; ++i)
+            {
+                var boneTransform = boneTransforms[i];
+
+                if (boneTransform == null ||  m_BoneData.ContainsKey(boneTransform))
+                    continue;
+
+                var bone = spriteBones[i];
+
+                if (view.IsActionHot(SkeletonAction.None))
+                    m_CachedBones.Add(boneTransform);
+
+                m_BoneData.Add(boneTransform, new Vector2(bone.length, alpha));
+            }
+        }
+
+        private void DoBoneGUI()
+        {
+            view.BeginLayout();
+
+            if (view.CanLayout())
+                LayoutBones();
+
+            view.EndLayout();
+
+            HandleSelectBone();
+            HandleRotateBone();
+            HandleMoveBone();
+            DrawBones();
+            DrawCursors();
+        }
+
+        private void LayoutBones()
+        {
+            foreach (var bone in m_CachedBones)
+            {
+                if (bone == null)
+                    continue;
+
+                Vector2 value;
+                if (!m_BoneData.TryGetValue(bone, out value))
+                    continue;
+
+                var length = value.x;
+
+                if (bone != hotBone)
+                    view.LayoutBone(bone.GetInstanceID(), bone.position, bone.position + bone.GetScaledRight() * length, bone.forward, bone.up, bone.right, false);
+            }
+        }
+
+        private void HandleSelectBone()
+        {
+            int instanceID;
+            bool additive;
+            if (view.DoSelectBone(out instanceID, out additive))
+            {
+                var bone = GetBone(instanceID);
+
+                if (!additive)
+                {
+                    if (!Selection.Contains(bone.gameObject))
+                        Selection.activeTransform = bone;
+                }
+                else
+                {
+                    var objectList = new List<Object>(Selection.objects);
+
+                    if(objectList.Contains(bone.gameObject))
+                        objectList.Remove(bone.gameObject);
+                    else
+                        objectList.Add(bone.gameObject);
+
+                    Selection.objects = objectList.ToArray();
+                }
+            }
+        }
+
+        private void HandleRotateBone()
+        {
+            var pivot = hoveredBone;
+
+            if (view.IsActionHot(SkeletonAction.RotateBone))
+                pivot = hotBone;
+
+            if (pivot == null)
+                return;
+
+            FindPivotTransform(pivot, out pivot);
+
+            if (pivot == null)
+                return;
+
+            float deltaAngle;
+            if (view.DoRotateBone(pivot.position, pivot.forward, out deltaAngle))
+                SetBoneRotation(deltaAngle);
+        }
+
+        private void HandleMoveBone()
+        {
+            Vector3 deltaPosition;
+            if (view.DoMoveBone(out deltaPosition))
+                SetBonePosition(deltaPosition);
+        }
+
+        private bool FindPivotTransform(Transform transform, out Transform selectedTransform)
+        {
+            selectedTransform = transform;
+            var selectedRoots = Selection.transforms;
+
+            foreach(var selectedRoot in selectedRoots)
+            {
+                if(transform.IsDescendentOf(selectedRoot))
+                {
+                    selectedTransform = selectedRoot;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private void SetBonePosition(Vector3 deltaPosition)
+        {
+            foreach (var selectedTransform in Selection.transforms)
+            {
+                if(!m_BoneData.ContainsKey(selectedTransform))
+                    continue;
+                
+                var boneTransform = selectedTransform;
+                
+                m_Undo.RecordObject(boneTransform, TextContent.moveBone);
+                boneTransform.position += deltaPosition;
+            }
+        }
+
+        private void SetBoneRotation(float deltaAngle)
+        {
+            foreach(var selectedGameObject in Selection.gameObjects)
+            {
+                if(!m_BoneData.ContainsKey(selectedGameObject.transform))
+                    continue;
+                
+                var boneTransform = selectedGameObject.transform;
+                
+                m_Undo.RecordObject(boneTransform, TextContent.rotateBone);
+                boneTransform.Rotate(boneTransform.forward, deltaAngle, Space.World);
+                InternalEngineBridge.SetLocalEulerHint(boneTransform);
+            }
+        }
+
+        private void DrawBones()
+        {
+            if (!view.IsRepainting())
+                return;
+
+            var selectedOutlineColor = SelectionOutlineSettings.outlineColor;
+            var selectedOutlineSize = SelectionOutlineSettings.selectedBoneOutlineSize;
+            var defaultOutlineColor = Color.black.AlphaMultiplied(0.5f);
+
+            //Draw bone outlines
+            foreach (var boneData in m_BoneData)
+            {
+                var bone = boneData.Key;
+
+                if (bone == null)
+                    continue;
+
+                var value = boneData.Value;
+                var length = value.x;
+                var alpha = value.y;
+
+                if (alpha == 0f || !bone.gameObject.activeInHierarchy)
+                    continue;
+
+                var color = defaultOutlineColor;
+                var outlineSize = 1.25f;
+
+                var isSelected = Selection.Contains(bone.gameObject);
+                var isHovered = hoveredBody == bone && view.IsActionHot(SkeletonAction.None);
+
+                if (isSelected)
+                {
+                    color = selectedOutlineColor;
+                    outlineSize = selectedOutlineSize * 0.5f + 1f;
+                }
+                else if (isHovered)
+                    color = Handles.preselectionColor;
+
+                DrawBoneOutline(bone, length, color, outlineSize);
+            }
+
+            //Draw bones
+            foreach (var boneData in m_BoneData)
+            {
+                var bone = boneData.Key;
+
+                if (bone == null)
+                    continue;
+
+                var value = boneData.Value;
+                var length = value.x;
+                var alpha = value.y;
+
+                if (alpha == 0f || !bone.gameObject.activeInHierarchy)
+                    continue;
+
+                DrawBone(bone, length, Color.white);
+            }
+        }
+
+        private void DrawBone(Transform bone, float length, Color color)
+        {
+            var isSelected = Selection.Contains(bone.gameObject);
+            var isJointHovered = view.IsActionHot(SkeletonAction.None) && hoveredJoint == bone;
+            var isTailHovered = view.IsActionHot(SkeletonAction.None) && hoveredTail == bone;
+
+            view.DrawBone(bone.position, bone.GetScaledRight(), bone.forward, length, color, false, isSelected, isJointHovered, isTailHovered, bone == hotBone);
+        }
+
+        private void DrawBoneOutline(Transform bone, float length, Color color, float outlineScale)
+        {
+            view.DrawBoneOutline(bone.position, bone.GetScaledRight(), bone.forward, length, color, outlineScale);
+        }
+
+        private void DrawCursors()
+        {
+            if (!view.IsRepainting())
+                return;
+
+            view.DrawCursors(true);
+        }
+
+        private bool HasParentBone(Transform transform)
+        {
+            Debug.Assert(transform != null);
+
+            return transform.parent != null && m_BoneData.ContainsKey(transform.parent);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c7af622df19d45f53f2f321012f0c0e5d7c37bf0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d0bd0aa54cffc442b82bc92946537e05
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmoToggle.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmoToggle.cs
new file mode 100644
index 0000000000000000000000000000000000000000..e4d94e2f912606acf756a24d24774a994f3e0585
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/BoneGizmoToggle.cs
@@ -0,0 +1,58 @@
+using UnityEngine;
+using UnityEngine.U2D.Animation;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal interface IBoneGizmoToggle
+    {
+        bool enableGizmos { get; }
+        void OnGUI();
+    }
+
+    internal class BoneGizmoToggle : IBoneGizmoToggle
+    {
+        private bool m_EnableGizmos;
+        private bool m_CurrentEnableGizmoState;
+
+        public bool enableGizmos
+        {
+            get { return m_CurrentEnableGizmoState; }
+        }
+
+        public BoneGizmoToggle()
+        {
+            SpriteSkin.onDrawGizmos.AddListener(OnDrawGizmos);
+        }
+
+        ~BoneGizmoToggle()
+        {
+            SpriteSkin.onDrawGizmos.RemoveListener(OnDrawGizmos);
+        }
+
+        //This callback will be called before OnSceneGUI in a Repaint event
+        private void OnDrawGizmos()
+        {
+            m_EnableGizmos = true;
+
+            //One time is enough
+            SpriteSkin.onDrawGizmos.RemoveListener(OnDrawGizmos);
+        }
+
+        public void OnGUI()
+        {
+            //Ignore events other than Repaint
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            if (m_CurrentEnableGizmoState != m_EnableGizmos)
+                SceneView.RepaintAll();
+
+            m_CurrentEnableGizmoState = m_EnableGizmos;
+
+            //Assume the Gizmo toggle is disabled and listen to the event again
+            m_EnableGizmos = false;
+            SpriteSkin.onDrawGizmos.RemoveListener(OnDrawGizmos);
+            SpriteSkin.onDrawGizmos.AddListener(OnDrawGizmos);
+        }
+    }
+}
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEditor.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..16f0acb4f83077b460b3203e1d61989e40152783
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c4ca39dfae364d0cabfa9898d2acfa1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs
new file mode 100644
index 0000000000000000000000000000000000000000..9b64f4e9f2bb11715b4a40c437031b6574405ad6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs
@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+
+#if ENABLE_ENTITIES
+
+    [CustomEditor(typeof(SpriteSkinEntity))]
+    [CanEditMultipleObjects]
+    class SpriteSkinEntityEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+          
+        }
+    }
+#endif
+
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b325f41002c1a8ffbc6ef730cc5da7ccaed37cec
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/SpriteSkinEntityEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22525e1e29f10a14db7e0bdf3b9f2a11
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs
new file mode 100644
index 0000000000000000000000000000000000000000..394615e22097ae07adf02faf6fb83b995a39feec
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs
@@ -0,0 +1,35 @@
+using UnityEngine;
+
+namespace UnityEditor.U2D.Animation
+{
+    internal static class TransformExtensions
+    {
+        public static Vector3 GetScaledRight(this Transform transform)
+        {
+            return transform.localToWorldMatrix.MultiplyVector(Vector3.right);
+        }
+
+        public static Vector3 GetScaledUp(this Transform transform)
+        {
+            return transform.localToWorldMatrix.MultiplyVector(Vector3.up);
+        }
+
+        public static bool IsDescendentOf(this Transform transform, Transform ancestor)
+        {
+            if (ancestor != null)
+            {
+                var parent = transform.parent;
+
+                while (parent != null)
+                {
+                    if (parent == ancestor)
+                        return true;
+
+                    parent = parent.parent;
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..318618d1c5d066c76720bd5a134cadf6313917f3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Editor/SpriteSkin/TransformExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 47d4401cb6fd9f54b9c33acc7881703d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs
new file mode 100644
index 0000000000000000000000000000000000000000..910549ff3202b371682a51e986798744a5fafc79
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs
@@ -0,0 +1,185 @@
+// -----------------------------------------------------------------------
+// <copyright file="Polygon.cs" company="">
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+    .Geometry
+{
+    using System;
+    using System.Linq;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// A polygon represented as a planar straight line graph.
+    /// </summary>
+    internal class Polygon : IPolygon
+    {
+        List<Vertex> points;
+        List<Point> holes;
+        List<RegionPointer> regions;
+
+        List<ISegment> segments;
+
+        /// <inheritdoc />
+        public List<Vertex> Points
+        {
+            get { return points; }
+        }
+
+        /// <inheritdoc />
+        public List<Point> Holes
+        {
+            get { return holes; }
+        }
+
+        /// <inheritdoc />
+        public List<RegionPointer> Regions
+        {
+            get { return regions; }
+        }
+
+        /// <inheritdoc />
+        public List<ISegment> Segments
+        {
+            get { return segments; }
+        }
+
+        /// <inheritdoc />
+        public bool HasPointMarkers { get; set; }
+
+        /// <inheritdoc />
+        public bool HasSegmentMarkers { get; set; }
+
+        /// <inheritdoc />
+        public int Count
+        {
+            get { return points.Count; }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Polygon" /> class.
+        /// </summary>
+        public Polygon()
+            : this(3, false)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Polygon" /> class.
+        /// </summary>
+        /// <param name="capacity">The default capacity for the points list.</param>
+        public Polygon(int capacity)
+            : this(3, false)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Polygon" /> class.
+        /// </summary>
+        /// <param name="capacity">The default capacity for the points list.</param>
+        /// <param name="markers">Use point and segment markers.</param>
+        public Polygon(int capacity, bool markers)
+        {
+            points = new List<Vertex>(capacity);
+            holes = new List<Point>();
+            regions = new List<RegionPointer>();
+
+            segments = new List<ISegment>();
+
+            HasPointMarkers = markers;
+            HasSegmentMarkers = markers;
+        }
+
+        [Obsolete("Use polygon.Add(contour) method instead.")]
+        public void AddContour(IEnumerable<Vertex> points, int marker = 0,
+            bool hole = false, bool convex = false)
+        {
+            this.Add(new Contour(points, marker, convex), hole);
+        }
+
+        [Obsolete("Use polygon.Add(contour) method instead.")]
+        public void AddContour(IEnumerable<Vertex> points, int marker, Point hole)
+        {
+            this.Add(new Contour(points, marker), hole);
+        }
+
+        /// <inheritdoc />
+        public Rectangle Bounds()
+        {
+            var bounds = new Rectangle();
+            bounds.Expand(this.points.Cast<Point>());
+
+            return bounds;
+        }
+
+        /// <summary>
+        /// Add a vertex to the polygon.
+        /// </summary>
+        /// <param name="vertex">The vertex to insert.</param>
+        public void Add(Vertex vertex)
+        {
+            this.points.Add(vertex);
+        }
+
+        /// <summary>
+        /// Add a segment to the polygon.
+        /// </summary>
+        /// <param name="segment">The segment to insert.</param>
+        /// <param name="insert">If true, both endpoints will be added to the points list.</param>
+        public void Add(ISegment segment, bool insert = false)
+        {
+            this.segments.Add(segment);
+
+            if (insert)
+            {
+                this.points.Add(segment.GetVertex(0));
+                this.points.Add(segment.GetVertex(1));
+            }
+        }
+
+        /// <summary>
+        /// Add a segment to the polygon.
+        /// </summary>
+        /// <param name="segment">The segment to insert.</param>
+        /// <param name="index">The index of the segment endpoint to add to the points list (must be 0 or 1).</param>
+        public void Add(ISegment segment, int index)
+        {
+            this.segments.Add(segment);
+
+            this.points.Add(segment.GetVertex(index));
+        }
+
+        /// <summary>
+        /// Add a contour to the polygon.
+        /// </summary>
+        /// <param name="contour">The contour to insert.</param>
+        /// <param name="hole">Treat contour as a hole.</param>
+        public void Add(Contour contour, bool hole = false)
+        {
+            if (hole)
+            {
+                this.Add(contour, contour.FindInteriorPoint());
+            }
+            else
+            {
+                this.points.AddRange(contour.Points);
+                this.segments.AddRange(contour.GetSegments());
+            }
+        }
+
+        /// <summary>
+        /// Add a contour to the polygon.
+        /// </summary>
+        /// <param name="contour">The contour to insert.</param>
+        /// <param name="hole">Point inside the contour, making it a hole.</param>
+        public void Add(Contour contour, Point hole)
+        {
+            this.points.AddRange(contour.Points);
+            this.segments.AddRange(contour.GetSegments());
+
+            this.holes.Add(hole);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..caccf1c610c5f676889e57db39d7510bc820fc9b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Geometry/Polygon.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7eb2e763592fc45778f3a2f7718c12fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/IO/TriangleWriter.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/IO/TriangleWriter.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..9a771e97d382087acb409ac4a18e4de036e8f2c9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/IO/TriangleWriter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2d813b6701ce64ba398e4a1d159ae1a3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Logging/ILog.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Logging/ILog.cs
new file mode 100644
index 0000000000000000000000000000000000000000..67098d9527386285f0c1665cc56a74c510ca4c13
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.animation@5.0.4/Runtime/Triangle/Logging/ILog.cs
@@ -0,0 +1,35 @@
+// -----------------------------------------------------------------------
+// <copyright file="ILog.cs" company="">
+// Triangle.NET code by Christian Woltering, http://triangle.codeplex.com/
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace UnityEngine.U2D.Animation.TriangleNet
+    .Logging
+{
+    using System.Collections.Generic;
+
+    internal enum LogLevel
+    {
+        Info = 0,
+        Warning = 1,
+        Error = 2
+    }
+
+    /// <summary>
+    /// A basic log interface.
+    /// </summary>
+    internal interface ILog<T> where T : ILogItem
+    {
+        void Add(T item);
+        void Clear();
+
+        void Info(string message);
+        void Error(string message, string info);
+        void Warning(string message, string info);
+
+        IList<T> Data { get; }
+
+        LogLevel Level { get; }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Documentation~/README.md b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Documentation~/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0a565f7a643760df0e2df318702c499c7115924
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Documentation~/README.md
@@ -0,0 +1,4 @@
+# Code Editor Package for Visual Studio Code
+
+This package is not intended to be modified by users.
+Nor does it provide any api intended to be included in user projects.
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/ProjectGeneration.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/ProjectGeneration.meta
new file mode 100644
index 0000000000000000000000000000000000000000..48ed36c1229aa09f90a8db3269ea1d1e46357f73
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/ProjectGeneration.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c779d3735d950f341ba35154e8b3234b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/Unity.com.unity.vscode.Editor.asmdef b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/Unity.com.unity.vscode.Editor.asmdef
new file mode 100644
index 0000000000000000000000000000000000000000..032da7cb5edea58ffe24739d4ca967b78c955145
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.ide.vscode@1.2.3/Editor/Unity.com.unity.vscode.Editor.asmdef
@@ -0,0 +1,9 @@
+{
+    "name": "Unity.VSCode.Editor",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": []
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b9523b2583f0ed77ec3f24107d2e3ed17e0075d9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d920c9d9a3133d242af38fd80330960f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c32f143ab0b4e6ea983bb3ffc4315abbd4f2ffac
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs
@@ -0,0 +1,943 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat3x2
+    {
+        [TestCompiler]
+        public static void float3x2_zero()
+        {
+            TestUtils.AreEqual(float3x2.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float3x2.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float3x2.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float3x2.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float3x2.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float3x2.zero.c1.z, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_equal_wide_wide()
+        {
+            float3x2 a0 = float3x2(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f);
+            float3x2 b0 = float3x2(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x2 a1 = float3x2(177.924438f, 335.5334f, 168.15448f, 350.729553f, 367.178467f, 46.9414673f);
+            float3x2 b1 = float3x2(-72.44382f, 362.97644f, 194.678345f, 471.644836f, -404.044678f, -144.696747f);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x2 a2 = float3x2(188.76416f, -97.2113953f, -293.320984f, -234.822937f, 417.0337f, 26.3864136f);
+            float3x2 b2 = float3x2(-494.446655f, -252.970367f, 234.417114f, 398.724f, 260.4287f, 370.144226f);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x2 a3 = float3x2(269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f);
+            float3x2 b3 = float3x2(89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_equal_wide_scalar()
+        {
+            float3x2 a0 = float3x2(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f);
+            float b0 = (-155.815765f);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x2 a1 = float3x2(314.671265f, 290.04895f, -132.6352f, -65.66748f, -69.68326f, -191.190765f);
+            float b1 = (386.365173f);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x2 a2 = float3x2(186.845215f, -319.144043f, -49.70108f, -300.8819f, 333.396851f, 386.3775f);
+            float b2 = (-232.895691f);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x2 a3 = float3x2(-296.7019f, 141.542358f, -227.323334f, 83.87286f, -410.91687f, 110.501282f);
+            float b3 = (-309.1172f);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float3x2 b0 = float3x2(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (428.311951f);
+            float3x2 b1 = float3x2(-489.501343f, -5.691559f, -30.8659363f, -362.9831f, 184.503174f, -160.470612f);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (316.668823f);
+            float3x2 b2 = float3x2(390.369263f, 505.1051f, -294.6487f, 443.1991f, 96.5592651f, -257.012939f);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (-245.054962f);
+            float3x2 b3 = float3x2(326.464844f, -23.9599f, -168.694885f, 386.2486f, -227.090637f, -336.612427f);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_not_equal_wide_wide()
+        {
+            float3x2 a0 = float3x2(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f);
+            float3x2 b0 = float3x2(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x2 a1 = float3x2(366.081543f, 154.542847f, 332.4262f, 397.11322f, -431.374969f, 489.0108f);
+            float3x2 b1 = float3x2(-457.730225f, -59.5232544f, 3.024231f, 155.812744f, -19.8399048f, -6.01693726f);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x2 a2 = float3x2(398.4336f, -489.817932f, 171.4049f, -67.82968f, -192.278717f, 227.84082f);
+            float3x2 b2 = float3x2(-406.207916f, -102.420715f, -40.362915f, 452.6754f, 93.25757f, -258.378052f);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x2 a3 = float3x2(62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f);
+            float3x2 b3 = float3x2(-184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_not_equal_wide_scalar()
+        {
+            float3x2 a0 = float3x2(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f);
+            float b0 = (-393.413544f);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x2 a1 = float3x2(-58.92328f, 492.20105f, -165.241516f, 270.341f, -380.243256f, 501.899048f);
+            float b1 = (-398.176849f);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x2 a2 = float3x2(-134.345459f, 46.7709961f, 161.459961f, 261.514221f, -145.6124f, -0.449920654f);
+            float b2 = (458.400452f);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x2 a3 = float3x2(350.461426f, 242.664f, 382.677063f, -468.967957f, -497.459473f, -80.93225f);
+            float b3 = (202.221008f);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float3x2 b0 = float3x2(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-338.100128f);
+            float3x2 b1 = float3x2(-152.314545f, -452.820679f, 209.439331f, 50.10797f, 372.4344f, -488.0213f);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (489.740784f);
+            float3x2 b2 = float3x2(270.4001f, -472.846771f, -286.850464f, -384.691864f, 443.423523f, 358.7472f);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (-15.4140625f);
+            float3x2 b3 = float3x2(-342.179169f, 468.967529f, -130.568085f, 401.785828f, -268.352264f, -239.231018f);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_wide_wide()
+        {
+            float3x2 a0 = float3x2(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f);
+            float3x2 b0 = float3x2(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f);
+            bool3x2 r0 = bool3x2(false, true, false, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x2 a1 = float3x2(3.38293457f, -144.301331f, -69.3696f, -135.667969f, -194.787354f, -33.473877f);
+            float3x2 b1 = float3x2(231.906311f, 179.49884f, 473.2249f, 15.8916626f, 270.049927f, 490.914f);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x2 a2 = float3x2(-19.67508f, 423.237976f, -71.6983f, -501.886f, 7.64386f, 302.262878f);
+            float3x2 b2 = float3x2(-185.734131f, 76.4331055f, 97.75232f, 419.300781f, 73.953186f, 481.032349f);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x2 a3 = float3x2(-140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f);
+            float3x2 b3 = float3x2(7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f);
+            bool3x2 r3 = bool3x2(true, true, false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_wide_scalar()
+        {
+            float3x2 a0 = float3x2(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f);
+            float b0 = (199.0675f);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x2 a1 = float3x2(282.9666f, -111.413147f, -288.081116f, 82.6654053f, -361.6429f, -68.0881958f);
+            float b1 = (258.2791f);
+            bool3x2 r1 = bool3x2(false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x2 a2 = float3x2(12.7880249f, -78.76297f, 25.7277222f, 101.37085f, -330.442657f, -48.9205322f);
+            float b2 = (-66.703064f);
+            bool3x2 r2 = bool3x2(false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x2 a3 = float3x2(359.604431f, 241.2768f, -183.437775f, 423.027161f, -334.622742f, -98.31558f);
+            float b3 = (-8.150085f);
+            bool3x2 r3 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float3x2 b0 = float3x2(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f);
+            bool3x2 r0 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (-299.744324f);
+            float3x2 b1 = float3x2(31.4371338f, -458.904541f, 13.6846924f, -458.5069f, 248.276489f, 389.231445f);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (488.745544f);
+            float3x2 b2 = float3x2(-221.637878f, -424.2672f, 249.059021f, -22.1361389f, -442.247742f, -340.857544f);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-95.1117249f);
+            float3x2 b3 = float3x2(15.4094238f, 87.29248f, 495.067627f, 316.0185f, -125.568115f, 122.164795f);
+            bool3x2 r3 = bool3x2(true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_wide_wide()
+        {
+            float3x2 a0 = float3x2(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f);
+            float3x2 b0 = float3x2(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f);
+            bool3x2 r0 = bool3x2(true, true, false, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x2 a1 = float3x2(-396.770355f, 127.037415f, 489.1399f, 51.9188843f, 155.384766f, -135.631653f);
+            float3x2 b1 = float3x2(-391.096039f, 479.283752f, -77.6748657f, -46.584198f, -415.377f, 71.46698f);
+            bool3x2 r1 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x2 a2 = float3x2(-425.978149f, -228.430511f, 383.03833f, 136.533569f, 8.602417f, -251.324371f);
+            float3x2 b2 = float3x2(-206.061035f, 360.8363f, 236.968811f, 14.550354f, 364.735168f, -159.06131f);
+            bool3x2 r2 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x2 a3 = float3x2(-345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f);
+            float3x2 b3 = float3x2(226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f);
+            bool3x2 r3 = bool3x2(false, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_wide_scalar()
+        {
+            float3x2 a0 = float3x2(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f);
+            float b0 = (-302.816956f);
+            bool3x2 r0 = bool3x2(true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x2 a1 = float3x2(173.575073f, 501.306824f, -367.027771f, -86.12451f, -489.090576f, -172.518158f);
+            float b1 = (69.26929f);
+            bool3x2 r1 = bool3x2(true, true, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x2 a2 = float3x2(-18.1496277f, -238.8945f, -27.2391357f, 471.779358f, 240.164551f, -481.4781f);
+            float b2 = (-236.414948f);
+            bool3x2 r2 = bool3x2(true, false, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x2 a3 = float3x2(185.59436f, -510.228149f, -183.2862f, -386.127655f, -13.6382141f, -7.34790039f);
+            float b3 = (33.29474f);
+            bool3x2 r3 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float3x2 b0 = float3x2(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (176.409241f);
+            float3x2 b1 = float3x2(-140.440033f, -182.48288f, -158.2933f, -162.685333f, -193.328674f, 230.181274f);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (-102.58783f);
+            float3x2 b2 = float3x2(392.520569f, -177.478668f, -10.2950134f, -24.04895f, 172.448669f, 374.048035f);
+            bool3x2 r2 = bool3x2(false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (-368.99762f);
+            float3x2 b3 = float3x2(-210.195282f, 149.470215f, -281.343262f, -100.469177f, 304.864441f, -361.524841f);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_equal_wide_wide()
+        {
+            float3x2 a0 = float3x2(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f);
+            float3x2 b0 = float3x2(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f);
+            bool3x2 r0 = bool3x2(false, true, false, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x2 a1 = float3x2(294.6701f, -327.564453f, -456.12326f, 282.30127f, 421.881165f, -311.71283f);
+            float3x2 b1 = float3x2(74.41406f, 260.916138f, 306.173279f, 139.564819f, -505.752472f, -489.6268f);
+            bool3x2 r1 = bool3x2(false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x2 a2 = float3x2(84.5675049f, 447.244629f, -154.494354f, -424.364746f, 36.68451f, 267.0703f);
+            float3x2 b2 = float3x2(-280.0326f, 303.1599f, 511.1902f, -104.659729f, 95.14661f, -125.636353f);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x2 a3 = float3x2(307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f);
+            float3x2 b3 = float3x2(376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f);
+            bool3x2 r3 = bool3x2(true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_equal_wide_scalar()
+        {
+            float3x2 a0 = float3x2(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f);
+            float b0 = (292.924255f);
+            bool3x2 r0 = bool3x2(false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x2 a1 = float3x2(-410.870056f, 183.821167f, 320.4425f, -257.870056f, -386.801758f, -182.938812f);
+            float b1 = (-483.902649f);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x2 a2 = float3x2(349.250122f, 373.5691f, 259.1515f, 450.130066f, -128.525543f, -43.8748779f);
+            float b2 = (485.311584f);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x2 a3 = float3x2(457.385742f, 479.451843f, -499.516449f, -398.132935f, 402.484863f, 87.91608f);
+            float b3 = (-77.6383057f);
+            bool3x2 r3 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float3x2 b0 = float3x2(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (288.5443f);
+            float3x2 b1 = float3x2(304.042847f, -148.618073f, -506.3001f, 27.5812378f, 48.47113f, 104.883484f);
+            bool3x2 r1 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-488.685852f);
+            float3x2 b2 = float3x2(-480.435181f, 421.936646f, 239.721069f, -101.018433f, -283.951477f, -55.24353f);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (-455.80484f);
+            float3x2 b3 = float3x2(131.107239f, -461.6988f, -388.482849f, -258.936035f, -225.223541f, -116.019989f);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_equal_wide_wide()
+        {
+            float3x2 a0 = float3x2(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f);
+            float3x2 b0 = float3x2(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f);
+            bool3x2 r0 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x2 a1 = float3x2(-122.535187f, 7.48144531f, 152.946411f, 48.9862061f, 57.3381348f, 300.4649f);
+            float3x2 b1 = float3x2(-373.302063f, 364.9359f, -322.7154f, 125.47821f, -25.77658f, 297.518921f);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x2 a2 = float3x2(349.25708f, 85.7496948f, -230.953308f, 418.711243f, -131.039917f, -126.512207f);
+            float3x2 b2 = float3x2(73.22235f, 462.783752f, 393.191345f, -95.0014343f, 381.357056f, 93.03192f);
+            bool3x2 r2 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x2 a3 = float3x2(-156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f);
+            float3x2 b3 = float3x2(254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f);
+            bool3x2 r3 = bool3x2(false, true, false, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_equal_wide_scalar()
+        {
+            float3x2 a0 = float3x2(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f);
+            float b0 = (189.205139f);
+            bool3x2 r0 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x2 a1 = float3x2(53.8151245f, -221.505463f, 252.994324f, -116.440369f, -395.3633f, 164.772583f);
+            float b1 = (-123.332947f);
+            bool3x2 r1 = bool3x2(true, false, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x2 a2 = float3x2(-287.007324f, 184.195557f, 273.012268f, -418.1424f, 249.3841f, 396.392151f);
+            float b2 = (355.837036f);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x2 a3 = float3x2(332.6654f, -335.12146f, -302.0869f, 254.442261f, 179.005066f, 71.1767f);
+            float b3 = (243.761414f);
+            bool3x2 r3 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float3x2 b0 = float3x2(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (-455.612579f);
+            float3x2 b1 = float3x2(276.665833f, 79.39917f, 416.420532f, 379.2735f, -439.5147f, 67.14099f);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (-74.56064f);
+            float3x2 b2 = float3x2(-367.256348f, 494.950745f, -61.2355347f, -429.170258f, -213.824677f, -264.310181f);
+            bool3x2 r2 = bool3x2(true, false, false, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (243.11377f);
+            float3x2 b3 = float3x2(-22.38388f, 304.862f, -323.686157f, 67.93805f, 125.303589f, -400.47052f);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_add_wide_wide()
+        {
+            float3x2 a0 = float3x2(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f);
+            float3x2 b0 = float3x2(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f);
+            float3x2 r0 = float3x2(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x2 a1 = float3x2(-470.536774f, -109.9501f, -178.701447f, -420.033783f, 290.711121f, -446.529633f);
+            float3x2 b1 = float3x2(267.49176f, 251.642517f, 244.495117f, -78.67575f, 352.2055f, 82.7791748f);
+            float3x2 r1 = float3x2(-203.045013f, 141.692413f, 65.79367f, -498.709534f, 642.9166f, -363.750458f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x2 a2 = float3x2(491.066467f, -261.1173f, -298.4069f, 502.4286f, 284.5943f, 401.128418f);
+            float3x2 b2 = float3x2(462.5473f, -405.492f, -428.498322f, -41.87259f, -269.9275f, 75.20447f);
+            float3x2 r2 = float3x2(953.6138f, -666.6093f, -726.9052f, 460.556f, 14.6668091f, 476.3329f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x2 a3 = float3x2(-36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f);
+            float3x2 b3 = float3x2(-141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f);
+            float3x2 r3 = float3x2(-178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_add_wide_scalar()
+        {
+            float3x2 a0 = float3x2(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f);
+            float b0 = (500.997253f);
+            float3x2 r0 = float3x2(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x2 a1 = float3x2(-2.79125977f, 443.115234f, 268.092224f, 41.3210449f, -471.256073f, -2.664978f);
+            float b1 = (-478.4148f);
+            float3x2 r1 = float3x2(-481.206055f, -35.29956f, -210.322571f, -437.09375f, -949.6709f, -481.079773f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x2 a2 = float3x2(78.98584f, 311.725464f, 10.3458252f, -151.244446f, 355.2328f, -197.800751f);
+            float b2 = (202.14801f);
+            float3x2 r2 = float3x2(281.13385f, 513.8735f, 212.493835f, 50.9035645f, 557.3808f, 4.34725952f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x2 a3 = float3x2(255.955261f, -181.626556f, -2.45492554f, 300.900635f, -236.491943f, -160.5841f);
+            float b3 = (244.1471f);
+            float3x2 r3 = float3x2(500.102356f, 62.52054f, 241.692169f, 545.0477f, 7.65515137f, 83.56299f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float3x2 b0 = float3x2(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f);
+            float3x2 r0 = float3x2(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (180.318115f);
+            float3x2 b1 = float3x2(337.579346f, -37.0550232f, 230.805f, -140.174347f, 18.02417f, -138.614349f);
+            float3x2 r1 = float3x2(517.897461f, 143.263092f, 411.1231f, 40.14377f, 198.342285f, 41.7037659f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (26.9041748f);
+            float3x2 b2 = float3x2(-374.5376f, 154.46759f, 268.38385f, -190.963013f, 188.617249f, -504.916138f);
+            float3x2 r2 = float3x2(-347.633423f, 181.371765f, 295.288025f, -164.058838f, 215.521423f, -478.011963f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (20.45404f);
+            float3x2 b3 = float3x2(197.945374f, 251.411926f, -421.0904f, 111.445374f, -73.26889f, 480.884583f);
+            float3x2 r3 = float3x2(218.399414f, 271.865967f, -400.636353f, 131.899414f, -52.81485f, 501.338623f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_sub_wide_wide()
+        {
+            float3x2 a0 = float3x2(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f);
+            float3x2 b0 = float3x2(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f);
+            float3x2 r0 = float3x2(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x2 a1 = float3x2(146.506592f, -130.585052f, 110.7771f, -235.5416f, 78.87933f, -347.686157f);
+            float3x2 b1 = float3x2(-125.6055f, -65.29901f, -477.876434f, 164.5f, 428.009583f, 72.62781f);
+            float3x2 r1 = float3x2(272.1121f, -65.28604f, 588.653564f, -400.0416f, -349.130249f, -420.313965f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x2 a2 = float3x2(-470.820557f, -11.45929f, -167.9479f, 330.676758f, -508.350861f, -252.031891f);
+            float3x2 b2 = float3x2(-446.8805f, 432.091431f, -225.554657f, -112.451965f, -210.6128f, -172.925049f);
+            float3x2 r2 = float3x2(-23.9400635f, -443.55072f, 57.60675f, 443.128723f, -297.738068f, -79.10684f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x2 a3 = float3x2(-427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f);
+            float3x2 b3 = float3x2(-80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f);
+            float3x2 r3 = float3x2(-347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_sub_wide_scalar()
+        {
+            float3x2 a0 = float3x2(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f);
+            float b0 = (-291.5904f);
+            float3x2 r0 = float3x2(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x2 a1 = float3x2(204.358337f, -377.9257f, -470.262054f, 400.5349f, 461.507568f, -246.287262f);
+            float b1 = (180.269714f);
+            float3x2 r1 = float3x2(24.088623f, -558.195435f, -650.531738f, 220.2652f, 281.237854f, -426.556976f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x2 a2 = float3x2(21.6052856f, -121.427368f, -122.718414f, -122.938721f, 360.15094f, 342.874573f);
+            float b2 = (246.350708f);
+            float3x2 r2 = float3x2(-224.745422f, -367.778076f, -369.069122f, -369.289429f, 113.800232f, 96.5238647f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x2 a3 = float3x2(18.92981f, 97.0437f, 485.914978f, -205.75766f, 253.443237f, -121.163055f);
+            float b3 = (164.602356f);
+            float3x2 r3 = float3x2(-145.672546f, -67.5586548f, 321.312622f, -370.360016f, 88.84088f, -285.7654f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float3x2 b0 = float3x2(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f);
+            float3x2 r0 = float3x2(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (-64.233f);
+            float3x2 b1 = float3x2(-66.04172f, 341.204956f, -385.775055f, 75.3947754f, 354.943726f, 169.131409f);
+            float3x2 r1 = float3x2(1.80871582f, -405.437958f, 321.542053f, -139.627777f, -419.176727f, -233.36441f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (88.21661f);
+            float3x2 b2 = float3x2(1.73498535f, 122.538025f, -264.945f, -50.83719f, -347.65033f, 4.06555176f);
+            float3x2 r2 = float3x2(86.48163f, -34.32141f, 353.161621f, 139.0538f, 435.866943f, 84.15106f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (-79.09543f);
+            float3x2 b3 = float3x2(354.358337f, -292.4925f, -53.2089844f, -246.3476f, 299.203369f, 432.1847f);
+            float3x2 r3 = float3x2(-433.453766f, 213.397064f, -25.8864441f, 167.252167f, -378.2988f, -511.280121f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mul_wide_wide()
+        {
+            float3x2 a0 = float3x2(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f);
+            float3x2 b0 = float3x2(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f);
+            float3x2 r0 = float3x2(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x2 a1 = float3x2(494.688477f, 53.5379639f, -239.4964f, 236.675842f, -211.8562f, -216.654816f);
+            float3x2 b1 = float3x2(207.732422f, 366.192871f, 358.880737f, 214.853577f, 253.422791f, -307.7138f);
+            float3x2 r1 = float3x2(102762.836f, 19605.22f, -85950.64f, 50850.6523f, -53689.19f, 66667.68f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x2 a2 = float3x2(467.9583f, -178.021912f, -386.394257f, -422.4354f, 464.589539f, -251.315674f);
+            float3x2 b2 = float3x2(184.47113f, 426.436462f, -144.281433f, 459.4796f, -358.313354f, -201.3652f);
+            float3x2 r2 = float3x2(86324.8f, -75915.03f, 55749.5156f, -194100.453f, -166468.641f, 50606.23f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x2 a3 = float3x2(-104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f);
+            float3x2 b3 = float3x2(254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f);
+            float3x2 r3 = float3x2(-26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mul_wide_scalar()
+        {
+            float3x2 a0 = float3x2(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f);
+            float b0 = (192.211182f);
+            float3x2 r0 = float3x2(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x2 a1 = float3x2(-477.3105f, -46.729187f, -238.405f, 422.08252f, -48.83484f, 355.30835f);
+            float b1 = (-438.272919f);
+            float3x2 r1 = float3x2(209192.266f, 20480.1367f, 104486.453f, -184987.344f, 21402.9883f, -155722.031f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x2 a2 = float3x2(119.356628f, 98.23602f, -325.552155f, 53.9373169f, -87.45099f, -130.474121f);
+            float b2 = (-196.995819f);
+            float3x2 r2 = float3x2(-23512.7559f, -19352.0859f, 64132.4141f, -10625.4258f, 17227.4785f, 25702.8555f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x2 a3 = float3x2(-222.594574f, 293.361084f, 174.381958f, -327.120056f, 56.62915f, 257.541565f);
+            float b3 = (126.015015f);
+            float3x2 r3 = float3x2(-28050.2578f, 36967.9023f, 21974.7441f, -41222.04f, 7136.123f, 32454.1035f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float3x2 b0 = float3x2(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f);
+            float3x2 r0 = float3x2(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (159.748108f);
+            float3x2 b1 = float3x2(-351.8222f, 491.801575f, 49.90204f, 424.4626f, 160.1181f, -395.9921f);
+            float3x2 r1 = float3x2(-56202.93f, 78564.37f, 7971.75635f, 67807.09f, 25578.5645f, -63258.99f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (125.20166f);
+            float3x2 b2 = float3x2(-265.0158f, 314.656128f, -292.712036f, -37.72989f, 165.362244f, 356.517761f);
+            float3x2 r2 = float3x2(-33180.418f, 39395.47f, -36648.03f, -4723.84473f, 20703.627f, 44636.6172f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (-188.813324f);
+            float3x2 b3 = float3x2(504.9157f, 40.5721436f, -206.775116f, -61.60269f, 118.971619f, 53.7483521f);
+            float3x2 r3 = float3x2(-95334.81f, -7660.56152f, 39041.9f, 11631.4092f, -22463.4277f, -10148.4053f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_div_wide_wide()
+        {
+            float3x2 a0 = float3x2(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f);
+            float3x2 b0 = float3x2(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f);
+            float3x2 r0 = float3x2(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x2 a1 = float3x2(360.41864f, 25.8097534f, -274.050476f, 127.538574f, -447.671753f, -137.458588f);
+            float3x2 b1 = float3x2(-93.2107849f, -442.005219f, 484.362732f, -390.7818f, 402.02533f, 316.6507f);
+            float3x2 r1 = float3x2(-3.86670542f, -0.0583924167f, -0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x2 a2 = float3x2(-136.133179f, 12.4376221f, 228.513f, 356.972351f, -24.7620544f, 411.6684f);
+            float3x2 b2 = float3x2(397.154419f, -303.2622f, -118.591248f, -81.6503f, -84.34686f, -488.419434f);
+            float3x2 r2 = float3x2(-0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f, 0.2935741f, -0.8428584f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x2 a3 = float3x2(-204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f);
+            float3x2 b3 = float3x2(404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f);
+            float3x2 r3 = float3x2(-0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_div_wide_scalar()
+        {
+            float3x2 a0 = float3x2(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f);
+            float b0 = (-60.0243835f);
+            float3x2 r0 = float3x2(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x2 a1 = float3x2(131.526611f, -348.9238f, -275.5387f, 210.557922f, 287.6424f, 504.372253f);
+            float b1 = (-261.8864f);
+            float3x2 r1 = float3x2(-0.5022277f, 1.33234787f, 1.05213058f, -0.8040047f, -1.0983479f, -1.92591989f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x2 a2 = float3x2(491.7871f, -253.236664f, 272.895142f, 178.096191f, -460.87558f, -502.646027f);
+            float b2 = (-26.6315918f);
+            float3x2 r2 = float3x2(-18.4663048f, 9.508882f, -10.2470455f, -6.687403f, 17.3055973f, 18.874052f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x2 a3 = float3x2(-84.3248f, 83.7963257f, 197.042053f, 317.168274f, 403.387146f, 81.6464844f);
+            float b3 = (-174.690338f);
+            float3x2 r3 = float3x2(0.482710153f, -0.479684949f, -1.12795055f, -1.8156029f, -2.30915546f, -0.467378378f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float3x2 b0 = float3x2(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f);
+            float3x2 r0 = float3x2(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (333.6645f);
+            float3x2 b1 = float3x2(38.2910767f, -472.979767f, 192.230164f, -200.296875f, -490.181519f, -211.10257f);
+            float3x2 r1 = float3x2(8.713897f, -0.7054519f, 1.73575509f, -1.66584969f, -0.6806958f, -1.58058f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (-322.852356f);
+            float3x2 b2 = float3x2(-137.985291f, 84.32971f, 355.063477f, 276.427246f, -382.988037f, -488.647156f);
+            float3x2 r2 = float3x2(2.339759f, -3.8284533f, -0.909280658f, -1.16794693f, 0.8429829f, 0.6607065f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (344.846f);
+            float3x2 b3 = float3x2(168.85498f, -44.1955872f, 420.55072f, -175.6152f, -9.220581f, -344.194275f);
+            float3x2 r3 = float3x2(2.04226136f, -7.802725f, 0.8199867f, -1.96364558f, -37.3995972f, -1.00189352f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mod_wide_wide()
+        {
+            float3x2 a0 = float3x2(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f);
+            float3x2 b0 = float3x2(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f);
+            float3x2 r0 = float3x2(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x2 a1 = float3x2(-101.348572f, 208.318542f, -140.770325f, 183.44696f, -463.368378f, 83.83911f);
+            float3x2 b1 = float3x2(487.0462f, -469.8291f, -145.203766f, -203.384f, -22.52008f, 224.69f);
+            float3x2 r1 = float3x2(-101.348572f, 208.318542f, -140.770325f, 183.44696f, -12.9667664f, 83.83911f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x2 a2 = float3x2(-64.71405f, 295.066833f, 212.25708f, 349.6283f, 119.875916f, -37.8058167f);
+            float3x2 b2 = float3x2(-435.62674f, 12.0955811f, 40.3787842f, 345.784851f, -433.471252f, -355.649963f);
+            float3x2 r2 = float3x2(-64.71405f, 4.772888f, 10.3631592f, 3.84344482f, 119.875916f, -37.8058167f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x2 a3 = float3x2(142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f);
+            float3x2 b3 = float3x2(4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f);
+            float3x2 r3 = float3x2(1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mod_wide_scalar()
+        {
+            float3x2 a0 = float3x2(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f);
+            float b0 = (-90.49924f);
+            float3x2 r0 = float3x2(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x2 a1 = float3x2(-450.807678f, -84.47363f, -318.7815f, 433.4547f, -54.60019f, -172.338867f);
+            float b1 = (186.094788f);
+            float3x2 r1 = float3x2(-78.6181f, -84.47363f, -132.6867f, 61.2651367f, -54.60019f, -172.338867f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x2 a2 = float3x2(-429.714661f, 5.79638672f, 254.5108f, -433.0937f, -203.082611f, -75.3564148f);
+            float b2 = (222.361877f);
+            float3x2 r2 = float3x2(-207.352783f, 5.79638672f, 32.1489258f, -210.731812f, -203.082611f, -75.3564148f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x2 a3 = float3x2(252.289124f, 5.337219f, -279.060425f, 483.5506f, -331.993347f, 336f);
+            float b3 = (-69.4039f);
+            float3x2 r3 = float3x2(44.0774231f, 5.337219f, -1.44482422f, 67.1272f, -54.3777466f, 58.3844f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float3x2 b0 = float3x2(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f);
+            float3x2 r0 = float3x2(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (397.0448f);
+            float3x2 b1 = float3x2(-393.890656f, -372.067078f, 201.012268f, -95.566864f, -258.951477f, 106.983582f);
+            float3x2 r1 = float3x2(3.15414429f, 24.9777222f, 196.032532f, 14.7773438f, 138.093323f, 76.0940552f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (469.323547f);
+            float3x2 b2 = float3x2(-34.80899f, 184.836548f, 374.79425f, -131.872711f, -120.092865f, 4.506653f);
+            float3x2 r2 = float3x2(16.8066711f, 99.65045f, 94.5293f, 73.7054138f, 109.044952f, 0.631652832f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (-111.401947f);
+            float3x2 b3 = float3x2(391.54248f, -218.668884f, 196.377441f, -511.032623f, 499.9535f, -433.523071f);
+            float3x2 r3 = float3x2(-111.401947f, -111.401947f, -111.401947f, -111.401947f, -111.401947f, -111.401947f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_plus()
+        {
+            float3x2 a0 = float3x2(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f);
+            float3x2 r0 = float3x2(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float3x2 a1 = float3x2(190.324646f, -320.518463f, 102.054382f, -107.00351f, -428.7762f, 377.230164f);
+            float3x2 r1 = float3x2(190.324646f, -320.518463f, 102.054382f, -107.00351f, -428.7762f, 377.230164f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float3x2 a2 = float3x2(234.773926f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f);
+            float3x2 r2 = float3x2(234.773926f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float3x2 a3 = float3x2(301.7851f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f);
+            float3x2 r3 = float3x2(301.7851f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_neg()
+        {
+            float3x2 a0 = float3x2(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f);
+            float3x2 r0 = float3x2(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float3x2 a1 = float3x2(-495.837952f, 19.68689f, 268.2367f, -180.600525f, 223.381287f, -410.392059f);
+            float3x2 r1 = float3x2(495.837952f, -19.68689f, -268.2367f, 180.600525f, -223.381287f, 410.392059f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float3x2 a2 = float3x2(-395.681549f, -110.9393f, -238.2196f, 292.543518f, 469.2926f, 48.29071f);
+            float3x2 r2 = float3x2(395.681549f, 110.9393f, 238.2196f, -292.543518f, -469.2926f, -48.29071f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float3x2 a3 = float3x2(88.7237549f, 55.7080078f, 464.541382f, 499.2428f, 175.015015f, 196.387573f);
+            float3x2 r3 = float3x2(-88.7237549f, -55.7080078f, -464.541382f, -499.2428f, -175.015015f, -196.387573f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_prefix_inc()
+        {
+            float3x2 a0 = float3x2(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f);
+            float3x2 r0 = float3x2(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float3x2 a1 = float3x2(-323.614868f, -76.50766f, -305.584778f, 64.0965f, 148.679321f, 363.2849f);
+            float3x2 r1 = float3x2(-322.614868f, -75.50766f, -304.584778f, 65.0965f, 149.679321f, 364.2849f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float3x2 a2 = float3x2(-115.559235f, -179.894653f, 339.8766f, -38.41043f, -153.373688f, 261.625549f);
+            float3x2 r2 = float3x2(-114.559235f, -178.894653f, 340.8766f, -37.41043f, -152.373688f, 262.625549f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float3x2 a3 = float3x2(155.030823f, 301.3058f, -221.355408f, -429.698151f, -271.2893f, -264.380066f);
+            float3x2 r3 = float3x2(156.030823f, 302.3058f, -220.355408f, -428.698151f, -270.2893f, -263.380066f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_postfix_inc()
+        {
+            float3x2 a0 = float3x2(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f);
+            float3x2 r0 = float3x2(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float3x2 a1 = float3x2(271.454651f, 153.7503f, -174.173f, -427.401062f, 215.110229f, 159.861023f);
+            float3x2 r1 = float3x2(271.454651f, 153.7503f, -174.173f, -427.401062f, 215.110229f, 159.861023f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float3x2 a2 = float3x2(-333.050446f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f);
+            float3x2 r2 = float3x2(-333.050446f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float3x2 a3 = float3x2(-449.9273f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f);
+            float3x2 r3 = float3x2(-449.9273f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_prefix_dec()
+        {
+            float3x2 a0 = float3x2(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f);
+            float3x2 r0 = float3x2(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float3x2 a1 = float3x2(337.968933f, 171.964539f, -227.44281f, 298.2848f, 326.5078f, 400.7209f);
+            float3x2 r1 = float3x2(336.968933f, 170.964539f, -228.44281f, 297.2848f, 325.5078f, 399.7209f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float3x2 a2 = float3x2(-478.031372f, -24.5845032f, 112.796875f, -341.9763f, -503.27417f, -79.6352539f);
+            float3x2 r2 = float3x2(-479.031372f, -25.5845032f, 111.796875f, -342.9763f, -504.27417f, -80.6352539f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float3x2 a3 = float3x2(-131.00415f, -15.7086487f, 188.758423f, 307.791931f, -406.667725f, 181.4751f);
+            float3x2 r3 = float3x2(-132.00415f, -16.7086487f, 187.758423f, 306.791931f, -407.667725f, 180.4751f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x2_operator_postfix_dec()
+        {
+            float3x2 a0 = float3x2(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f);
+            float3x2 r0 = float3x2(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float3x2 a1 = float3x2(-281.1117f, -182.405731f, 450.1281f, -129.232666f, -332.154968f, -261.0089f);
+            float3x2 r1 = float3x2(-281.1117f, -182.405731f, 450.1281f, -129.232666f, -332.154968f, -261.0089f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float3x2 a2 = float3x2(205.461121f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f);
+            float3x2 r2 = float3x2(205.461121f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float3x2 a3 = float3x2(-396.302063f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f);
+            float3x2 r3 = float3x2(-396.302063f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e0a2446bdd46326881d56bc90001c00dd9319286
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c2a01faa80e74147aeb6f5a1d9fc18d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..a8c8d87d9c0b06916256e6da635b246a23078128
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs
@@ -0,0 +1,960 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat3x3
+    {
+        [TestCompiler]
+        public static void float3x3_zero()
+        {
+            TestUtils.AreEqual(float3x3.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c1.z, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c2.x, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c2.y, 0.0f);
+            TestUtils.AreEqual(float3x3.zero.c2.z, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_identity()
+        {
+            TestUtils.AreEqual(float3x3.identity.c0.x, 1.0f);
+            TestUtils.AreEqual(float3x3.identity.c0.y, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c0.z, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c1.x, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c1.y, 1.0f);
+            TestUtils.AreEqual(float3x3.identity.c1.z, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c2.x, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c2.y, 0.0f);
+            TestUtils.AreEqual(float3x3.identity.c2.z, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_equal_wide_wide()
+        {
+            float3x3 a0 = float3x3(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f, 177.924438f, 335.5334f, 168.15448f);
+            float3x3 b0 = float3x3(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f, -72.44382f, 362.97644f, 194.678345f);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x3 a1 = float3x3(350.729553f, 367.178467f, 46.9414673f, 188.76416f, -97.2113953f, -293.320984f, -234.822937f, 417.0337f, 26.3864136f);
+            float3x3 b1 = float3x3(471.644836f, -404.044678f, -144.696747f, -494.446655f, -252.970367f, 234.417114f, 398.724f, 260.4287f, 370.144226f);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x3 a2 = float3x3(269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f, -22.98944f, 487.260864f, -419.731964f);
+            float3x3 b2 = float3x3(89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f, -174.081818f, 395.101135f, 350.3393f);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x3 a3 = float3x3(337.2033f, 245.043884f, 390.215881f, 84.4129639f, 434.2079f, -68.7284241f, 485.769958f, 413.169739f, -418.2693f);
+            float3x3 b3 = float3x3(-243.144592f, -416.397369f, 151.576477f, -18.2243347f, -431.677917f, -468.330963f, 429.495728f, 477.389221f, -433.4254f);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_equal_wide_scalar()
+        {
+            float3x3 a0 = float3x3(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f, 314.671265f, 386.365173f, 290.04895f);
+            float b0 = (-155.815765f);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x3 a1 = float3x3(-132.6352f, -69.68326f, -191.190765f, 186.845215f, -232.895691f, -319.144043f, -49.70108f, -300.8819f, 333.396851f);
+            float b1 = (-65.66748f);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x3 a2 = float3x3(386.3775f, -309.1172f, 141.542358f, -227.323334f, 83.87286f, -410.91687f, 110.501282f, -390.103577f, 36.57434f);
+            float b2 = (-296.7019f);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x3 a3 = float3x3(-427.541443f, 175.8117f, -193.47995f, 291.051941f, 423.97168f, -429.8739f, -275.156952f, -56.3323669f, -95.83597f);
+            float b3 = (-268.170837f);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float3x3 b0 = float3x3(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f, 428.311951f, -489.501343f, -5.691559f);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (-30.8659363f);
+            float3x3 b1 = float3x3(-362.9831f, 184.503174f, -160.470612f, 316.668823f, 390.369263f, 505.1051f, -294.6487f, 443.1991f, 96.5592651f);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (-257.012939f);
+            float3x3 b2 = float3x3(-245.054962f, 326.464844f, -23.9599f, -168.694885f, 386.2486f, -227.090637f, -336.612427f, 365.108154f, -405.390839f);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (-473.995483f);
+            float3x3 b3 = float3x3(298.435364f, -149.86322f, 450.0664f, 153.47644f, 56.28778f, 39.3421021f, -350.403717f, -482.717224f, 239.9654f);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_not_equal_wide_wide()
+        {
+            float3x3 a0 = float3x3(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f, 366.081543f, 154.542847f, 332.4262f);
+            float3x3 b0 = float3x3(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f, -457.730225f, -59.5232544f, 3.024231f);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x3 a1 = float3x3(397.11322f, -431.374969f, 489.0108f, 398.4336f, -489.817932f, 171.4049f, -67.82968f, -192.278717f, 227.84082f);
+            float3x3 b1 = float3x3(155.812744f, -19.8399048f, -6.01693726f, -406.207916f, -102.420715f, -40.362915f, 452.6754f, 93.25757f, -258.378052f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x3 a2 = float3x3(62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f, -72.20682f, 444.749268f, 238.81781f);
+            float3x3 b2 = float3x3(-184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f, 415.071716f, -467.726135f, -433.784668f);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x3 a3 = float3x3(365.1801f, -437.9229f, -362.442627f, 445.954346f, -0.417480469f, -506.828369f, 245.477051f, -173.571045f, 390.338562f);
+            float3x3 b3 = float3x3(-212.165924f, 474.674927f, 452.483215f, -92.11273f, -385.9221f, 420.2151f, -239.176056f, -99.0791f, 4.476013f);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_not_equal_wide_scalar()
+        {
+            float3x3 a0 = float3x3(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f, -58.92328f, -398.176849f, 492.20105f);
+            float b0 = (-393.413544f);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x3 a1 = float3x3(-165.241516f, -380.243256f, 501.899048f, -134.345459f, 458.400452f, 46.7709961f, 161.459961f, 261.514221f, -145.6124f);
+            float b1 = (270.341f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x3 a2 = float3x3(-0.449920654f, 202.221008f, 242.664f, 382.677063f, -468.967957f, -497.459473f, -80.93225f, -328.587769f, -506.490326f);
+            float b2 = (350.461426f);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x3 a3 = float3x3(449.348145f, 249.181824f, -338.468536f, 229.670654f, -76.5433044f, 317.286072f, 401.939575f, 210.984863f, -147.096313f);
+            float b3 = (210.771f);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float3x3 b0 = float3x3(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f, -338.100128f, -152.314545f, -452.820679f);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (209.439331f);
+            float3x3 b1 = float3x3(50.10797f, 372.4344f, -488.0213f, 489.740784f, 270.4001f, -472.846771f, -286.850464f, -384.691864f, 443.423523f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (358.7472f);
+            float3x3 b2 = float3x3(-15.4140625f, -342.179169f, 468.967529f, -130.568085f, 401.785828f, -268.352264f, -239.231018f, 411.386536f, 139.769348f);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (334.522034f);
+            float3x3 b3 = float3x3(-223.629242f, -12.4884644f, 113.468872f, -189.652252f, -212.846558f, 306.1256f, -178.330383f, 382.141968f, -340.8656f);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_wide_wide()
+        {
+            float3x3 a0 = float3x3(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f, 3.38293457f, -144.301331f, -69.3696f);
+            float3x3 b0 = float3x3(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f, 231.906311f, 179.49884f, 473.2249f);
+            bool3x3 r0 = bool3x3(false, true, false, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x3 a1 = float3x3(-135.667969f, -194.787354f, -33.473877f, -19.67508f, 423.237976f, -71.6983f, -501.886f, 7.64386f, 302.262878f);
+            float3x3 b1 = float3x3(15.8916626f, 270.049927f, 490.914f, -185.734131f, 76.4331055f, 97.75232f, 419.300781f, 73.953186f, 481.032349f);
+            bool3x3 r1 = bool3x3(true, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x3 a2 = float3x3(-140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f, 269.1078f, 462.98822f, 223.884155f);
+            float3x3 b2 = float3x3(7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f, -382.315857f, 251.535156f, 143.17395f);
+            bool3x3 r2 = bool3x3(true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x3 a3 = float3x3(-287.18924f, 283.6386f, 511.864319f, -60.4967957f, -234.303467f, -316.1384f, -417.522156f, 441.643433f, -191.950623f);
+            float3x3 b3 = float3x3(293.660339f, -292.769562f, -43.2182f, -353.4112f, 458.32605f, -114.556458f, 441.429749f, -113.333679f, 435.622925f);
+            bool3x3 r3 = bool3x3(true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_wide_scalar()
+        {
+            float3x3 a0 = float3x3(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f, 282.9666f, 258.2791f, -111.413147f);
+            float b0 = (199.0675f);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x3 a1 = float3x3(-288.081116f, -361.6429f, -68.0881958f, 12.7880249f, -66.703064f, -78.76297f, 25.7277222f, 101.37085f, -330.442657f);
+            float b1 = (82.6654053f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x3 a2 = float3x3(-48.9205322f, -8.150085f, 241.2768f, -183.437775f, 423.027161f, -334.622742f, -98.31558f, 300.410156f, 297.925232f);
+            float b2 = (359.604431f);
+            bool3x3 r2 = bool3x3(true, true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x3 a3 = float3x3(-492.108154f, 95.78882f, -220.62146f, -455.37558f, 360.291565f, -296.372131f, 272.488342f, 360.207947f, 389.727417f);
+            float b3 = (-395.807251f);
+            bool3x3 r3 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float3x3 b0 = float3x3(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f, -299.744324f, 31.4371338f, -458.904541f);
+            bool3x3 r0 = bool3x3(false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (13.6846924f);
+            float3x3 b1 = float3x3(-458.5069f, 248.276489f, 389.231445f, 488.745544f, -221.637878f, -424.2672f, 249.059021f, -22.1361389f, -442.247742f);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (-340.857544f);
+            float3x3 b2 = float3x3(-95.1117249f, 15.4094238f, 87.29248f, 495.067627f, 316.0185f, -125.568115f, 122.164795f, 96.75537f, -228.906342f);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-143.9527f);
+            float3x3 b3 = float3x3(-230.238281f, -327.6126f, 103.39801f, 434.488831f, -157.4502f, 190.572144f, 108.2583f, 132.550781f, -431.515228f);
+            bool3x3 r3 = bool3x3(false, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_wide_wide()
+        {
+            float3x3 a0 = float3x3(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f, -396.770355f, 127.037415f, 489.1399f);
+            float3x3 b0 = float3x3(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f, -391.096039f, 479.283752f, -77.6748657f);
+            bool3x3 r0 = bool3x3(true, true, false, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x3 a1 = float3x3(51.9188843f, 155.384766f, -135.631653f, -425.978149f, -228.430511f, 383.03833f, 136.533569f, 8.602417f, -251.324371f);
+            float3x3 b1 = float3x3(-46.584198f, -415.377f, 71.46698f, -206.061035f, 360.8363f, 236.968811f, 14.550354f, 364.735168f, -159.06131f);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x3 a2 = float3x3(-345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f, 105.535217f, -170.9253f, 26.9802246f);
+            float3x3 b2 = float3x3(226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f, -352.1598f, 9.822632f, 186.721619f);
+            bool3x3 r2 = bool3x3(false, false, false, true, true, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x3 a3 = float3x3(-188.928314f, 201.786621f, -506.057159f, 15.454895f, 115.080688f, -496.971832f, 339.888123f, 372.228333f, 313.2387f);
+            float3x3 b3 = float3x3(-325.913635f, -77.93036f, -379.746033f, 251.45575f, -144.183563f, 337.8899f, -249.505554f, -225.9013f, -249.491272f);
+            bool3x3 r3 = bool3x3(true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_wide_scalar()
+        {
+            float3x3 a0 = float3x3(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f, 173.575073f, 69.26929f, 501.306824f);
+            float b0 = (-302.816956f);
+            bool3x3 r0 = bool3x3(true, false, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x3 a1 = float3x3(-367.027771f, -489.090576f, -172.518158f, -18.1496277f, -236.414948f, -238.8945f, -27.2391357f, 471.779358f, 240.164551f);
+            float b1 = (-86.12451f);
+            bool3x3 r1 = bool3x3(false, false, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x3 a2 = float3x3(-481.4781f, 33.29474f, -510.228149f, -183.2862f, -386.127655f, -13.6382141f, -7.34790039f, -261.865967f, 52.24951f);
+            float b2 = (185.59436f);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x3 a3 = float3x3(16.3232422f, -262.2675f, -458.255981f, -218.866119f, -34.6923523f, 290.573059f, 180.2633f, -482.863953f, 100.7063f);
+            float b3 = (-410.5101f);
+            bool3x3 r3 = bool3x3(true, true, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float3x3 b0 = float3x3(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f, 176.409241f, -140.440033f, -182.48288f);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (-158.2933f);
+            float3x3 b1 = float3x3(-162.685333f, -193.328674f, 230.181274f, -102.58783f, 392.520569f, -177.478668f, -10.2950134f, -24.04895f, 172.448669f);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (374.048035f);
+            float3x3 b2 = float3x3(-368.99762f, -210.195282f, 149.470215f, -281.343262f, -100.469177f, 304.864441f, -361.524841f, -372.452362f, -33.9095459f);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (-69.5952759f);
+            float3x3 b3 = float3x3(-460.4324f, -309.341675f, 486.131531f, 471.920959f, 479.361572f, -107.004181f, 331.636536f, -340.840149f, -384.2146f);
+            bool3x3 r3 = bool3x3(true, true, false, false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_equal_wide_wide()
+        {
+            float3x3 a0 = float3x3(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f, 294.6701f, -327.564453f, -456.12326f);
+            float3x3 b0 = float3x3(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f, 74.41406f, 260.916138f, 306.173279f);
+            bool3x3 r0 = bool3x3(false, true, false, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x3 a1 = float3x3(282.30127f, 421.881165f, -311.71283f, 84.5675049f, 447.244629f, -154.494354f, -424.364746f, 36.68451f, 267.0703f);
+            float3x3 b1 = float3x3(139.564819f, -505.752472f, -489.6268f, -280.0326f, 303.1599f, 511.1902f, -104.659729f, 95.14661f, -125.636353f);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x3 a2 = float3x3(307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f, -77.04346f, 438.1848f, 260.282349f);
+            float3x3 b2 = float3x3(376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f, -216.002319f, 66.73425f, 99.21863f);
+            bool3x3 r2 = bool3x3(true, false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x3 a3 = float3x3(386.034058f, -281.491f, -102.930054f, -346.716736f, -258.3412f, -383.302948f, -5.14703369f, 319.34375f, 465.022217f);
+            float3x3 b3 = float3x3(233.843018f, 439.839966f, 61.1151123f, -219.030579f, -404.7129f, -202.748352f, -312.476471f, 310.0719f, -320.363037f);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_equal_wide_scalar()
+        {
+            float3x3 a0 = float3x3(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f, -410.870056f, -483.902649f, 183.821167f);
+            float b0 = (292.924255f);
+            bool3x3 r0 = bool3x3(false, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x3 a1 = float3x3(320.4425f, -386.801758f, -182.938812f, 349.250122f, 485.311584f, 373.5691f, 259.1515f, 450.130066f, -128.525543f);
+            float b1 = (-257.870056f);
+            bool3x3 r1 = bool3x3(false, true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x3 a2 = float3x3(-43.8748779f, -77.6383057f, 479.451843f, -499.516449f, -398.132935f, 402.484863f, 87.91608f, -502.1736f, 125.950806f);
+            float b2 = (457.385742f);
+            bool3x3 r2 = bool3x3(true, true, false, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x3 a3 = float3x3(-54.49362f, 97.94293f, 228.021545f, -213.378662f, 42.2608032f, -24.8275757f, -451.0416f, 429.577576f, -308.4343f);
+            float b3 = (250.667419f);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float3x3 b0 = float3x3(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f, 288.5443f, 304.042847f, -148.618073f);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (-506.3001f);
+            float3x3 b1 = float3x3(27.5812378f, 48.47113f, 104.883484f, -488.685852f, -480.435181f, 421.936646f, 239.721069f, -101.018433f, -283.951477f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-55.24353f);
+            float3x3 b2 = float3x3(-455.80484f, 131.107239f, -461.6988f, -388.482849f, -258.936035f, -225.223541f, -116.019989f, -442.595245f, 297.333374f);
+            bool3x3 r2 = bool3x3(false, true, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (36.6872559f);
+            float3x3 b3 = float3x3(485.097839f, 344.445679f, 237.592163f, 230.390869f, -413.9848f, -215.901672f, 39.5603638f, 22.947998f, -162.060577f);
+            bool3x3 r3 = bool3x3(true, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_equal_wide_wide()
+        {
+            float3x3 a0 = float3x3(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f, -122.535187f, 7.48144531f, 152.946411f);
+            float3x3 b0 = float3x3(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f, -373.302063f, 364.9359f, -322.7154f);
+            bool3x3 r0 = bool3x3(false, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x3 a1 = float3x3(48.9862061f, 57.3381348f, 300.4649f, 349.25708f, 85.7496948f, -230.953308f, 418.711243f, -131.039917f, -126.512207f);
+            float3x3 b1 = float3x3(125.47821f, -25.77658f, 297.518921f, 73.22235f, 462.783752f, 393.191345f, -95.0014343f, 381.357056f, 93.03192f);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x3 a2 = float3x3(-156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f, -223.492981f, 302.123f, 459.852722f);
+            float3x3 b2 = float3x3(254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f, 453.684875f, -154.011658f, -97.29007f);
+            bool3x3 r2 = bool3x3(false, true, false, true, false, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x3 a3 = float3x3(-347.128021f, 364.9781f, 212.635437f, 504.276062f, -142.232971f, -132.2218f, 303.683777f, 265.210144f, 9.754395f);
+            float3x3 b3 = float3x3(151.184753f, 57.36029f, -194.207092f, -462.670624f, 113.3866f, -129.3533f, 8.107788f, 426.449524f, 410.693176f);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_equal_wide_scalar()
+        {
+            float3x3 a0 = float3x3(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f, 53.8151245f, -123.332947f, -221.505463f);
+            float b0 = (189.205139f);
+            bool3x3 r0 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x3 a1 = float3x3(252.994324f, -395.3633f, 164.772583f, -287.007324f, 355.837036f, 184.195557f, 273.012268f, -418.1424f, 249.3841f);
+            float b1 = (-116.440369f);
+            bool3x3 r1 = bool3x3(true, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x3 a2 = float3x3(396.392151f, 243.761414f, -335.12146f, -302.0869f, 254.442261f, 179.005066f, 71.1767f, -331.271667f, 307.890564f);
+            float b2 = (332.6654f);
+            bool3x3 r2 = bool3x3(true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x3 a3 = float3x3(-388.578522f, -219.892578f, -491.681f, 30.99707f, 199.232239f, -74.50003f, -343.386475f, 216.031555f, -420.403137f);
+            float b3 = (150.605774f);
+            bool3x3 r3 = bool3x3(false, false, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float3x3 b0 = float3x3(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f, -455.612579f, 276.665833f, 79.39917f);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (416.420532f);
+            float3x3 b1 = float3x3(379.2735f, -439.5147f, 67.14099f, -74.56064f, -367.256348f, 494.950745f, -61.2355347f, -429.170258f, -213.824677f);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (-264.310181f);
+            float3x3 b2 = float3x3(243.11377f, -22.38388f, 304.862f, -323.686157f, 67.93805f, 125.303589f, -400.47052f, -283.159637f, -42.31961f);
+            bool3x3 r2 = bool3x3(false, false, false, true, false, false, true, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (-429.510376f);
+            float3x3 b3 = float3x3(499.395874f, -289.963074f, -136.008789f, -351.125244f, -381.8183f, 393.3009f, 18.02362f, -169.92392f, -285.884949f);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_add_wide_wide()
+        {
+            float3x3 a0 = float3x3(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f, -470.536774f, -109.9501f, -178.701447f);
+            float3x3 b0 = float3x3(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f, 267.49176f, 251.642517f, 244.495117f);
+            float3x3 r0 = float3x3(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f, -203.045013f, 141.692413f, 65.79367f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x3 a1 = float3x3(-420.033783f, 290.711121f, -446.529633f, 491.066467f, -261.1173f, -298.4069f, 502.4286f, 284.5943f, 401.128418f);
+            float3x3 b1 = float3x3(-78.67575f, 352.2055f, 82.7791748f, 462.5473f, -405.492f, -428.498322f, -41.87259f, -269.9275f, 75.20447f);
+            float3x3 r1 = float3x3(-498.709534f, 642.9166f, -363.750458f, 953.6138f, -666.6093f, -726.9052f, 460.556f, 14.6668091f, 476.3329f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x3 a2 = float3x3(-36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f, -62.8800049f, -79.5522461f, 413.098267f);
+            float3x3 b2 = float3x3(-141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f, 492.692444f, 439.043823f, -511.742767f);
+            float3x3 r2 = float3x3(-178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f, 429.812439f, 359.491577f, -98.6445f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x3 a3 = float3x3(-100.877594f, 418.524f, -183.143127f, 407.443726f, 300.486023f, -261.126129f, -309.830353f, 378.363342f, -224.094f);
+            float3x3 b3 = float3x3(-399.057129f, -315.868469f, -228.07724f, -171.7052f, 467.17395f, -474.822937f, 311.390747f, 326.8454f, 475.2119f);
+            float3x3 r3 = float3x3(-499.934723f, 102.655518f, -411.220367f, 235.738525f, 767.66f, -735.9491f, 1.56039429f, 705.20874f, 251.11792f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_add_wide_scalar()
+        {
+            float3x3 a0 = float3x3(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f, -2.79125977f, -478.4148f, 443.115234f);
+            float b0 = (500.997253f);
+            float3x3 r0 = float3x3(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f, 498.206f, 22.5824585f, 944.1125f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x3 a1 = float3x3(268.092224f, -471.256073f, -2.664978f, 78.98584f, 202.14801f, 311.725464f, 10.3458252f, -151.244446f, 355.2328f);
+            float b1 = (41.3210449f);
+            float3x3 r1 = float3x3(309.413269f, -429.935028f, 38.6560669f, 120.306885f, 243.469055f, 353.0465f, 51.66687f, -109.9234f, 396.553833f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x3 a2 = float3x3(-197.800751f, 244.1471f, -181.626556f, -2.45492554f, 300.900635f, -236.491943f, -160.5841f, -172.5422f, -242.9411f);
+            float b2 = (255.955261f);
+            float3x3 r2 = float3x3(58.15451f, 500.102356f, 74.3287048f, 253.500336f, 556.8559f, 19.4633179f, 95.3711548f, 83.4130554f, 13.01416f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x3 a3 = float3x3(466.344116f, 264.294f, 372.866821f, -198.837769f, -381.930969f, 402.160339f, -117.024841f, 497.373779f, 485.9093f);
+            float b3 = (237.987488f);
+            float3x3 r3 = float3x3(704.3316f, 502.2815f, 610.8543f, 39.14972f, -143.943481f, 640.1478f, 120.962646f, 735.361267f, 723.8968f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float3x3 b0 = float3x3(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f, 180.318115f, 337.579346f, -37.0550232f);
+            float3x3 r0 = float3x3(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f, -145.194641f, 12.0665894f, -362.56778f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (230.805f);
+            float3x3 b1 = float3x3(-140.174347f, 18.02417f, -138.614349f, 26.9041748f, -374.5376f, 154.46759f, 268.38385f, -190.963013f, 188.617249f);
+            float3x3 r1 = float3x3(90.6306458f, 248.829163f, 92.19064f, 257.709167f, -143.7326f, 385.272583f, 499.188843f, 39.84198f, 419.422241f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (-504.916138f);
+            float3x3 b2 = float3x3(20.45404f, 197.945374f, 251.411926f, -421.0904f, 111.445374f, -73.26889f, 480.884583f, 438.05304f, 66.8443f);
+            float3x3 r2 = float3x3(-484.4621f, -306.970764f, -253.504211f, -926.006531f, -393.470764f, -578.185059f, -24.0315552f, -66.8631f, -438.071838f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (-270.796021f);
+            float3x3 b3 = float3x3(-44.02191f, 197.6947f, 19.1139526f, 349.2378f, 366.2345f, -413.4803f, -260.720184f, 77.54236f, 183.9549f);
+            float3x3 r3 = float3x3(-314.817932f, -73.10132f, -251.682068f, 78.44177f, 95.43848f, -684.2763f, -531.516235f, -193.253662f, -86.8411255f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_sub_wide_wide()
+        {
+            float3x3 a0 = float3x3(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f, 146.506592f, -130.585052f, 110.7771f);
+            float3x3 b0 = float3x3(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f, -125.6055f, -65.29901f, -477.876434f);
+            float3x3 r0 = float3x3(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f, 272.1121f, -65.28604f, 588.653564f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x3 a1 = float3x3(-235.5416f, 78.87933f, -347.686157f, -470.820557f, -11.45929f, -167.9479f, 330.676758f, -508.350861f, -252.031891f);
+            float3x3 b1 = float3x3(164.5f, 428.009583f, 72.62781f, -446.8805f, 432.091431f, -225.554657f, -112.451965f, -210.6128f, -172.925049f);
+            float3x3 r1 = float3x3(-400.0416f, -349.130249f, -420.313965f, -23.9400635f, -443.55072f, 57.60675f, 443.128723f, -297.738068f, -79.10684f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x3 a2 = float3x3(-427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f, -308.939575f, 454.5334f, 26.1069336f);
+            float3x3 b2 = float3x3(-80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f, -221.325439f, -9.25882f, 288.173828f);
+            float3x3 r2 = float3x3(-347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f, -87.6141357f, 463.7922f, -262.0669f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x3 a3 = float3x3(-482.711823f, -40.8535461f, 318.380676f, 475.210815f, 134.926941f, 388.481567f, 138.7182f, -385.5736f, -149.3648f);
+            float3x3 b3 = float3x3(217.36145f, 307.540039f, -262.412659f, -405.378021f, 400.004333f, 72.11908f, -154.880585f, -469.659973f, -320.615417f);
+            float3x3 r3 = float3x3(-700.073242f, -348.3936f, 580.793335f, 880.588867f, -265.0774f, 316.3625f, 293.5988f, 84.0863647f, 171.25061f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_sub_wide_scalar()
+        {
+            float3x3 a0 = float3x3(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f, 204.358337f, 180.269714f, -377.9257f);
+            float b0 = (-291.5904f);
+            float3x3 r0 = float3x3(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f, 495.94873f, 471.8601f, -86.3353f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x3 a1 = float3x3(-470.262054f, 461.507568f, -246.287262f, 21.6052856f, 246.350708f, -121.427368f, -122.718414f, -122.938721f, 360.15094f);
+            float b1 = (400.5349f);
+            float3x3 r1 = float3x3(-870.797f, 60.9726563f, -646.822144f, -378.929626f, -154.1842f, -521.9623f, -523.2533f, -523.473633f, -40.3839722f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x3 a2 = float3x3(342.874573f, 164.602356f, 97.0437f, 485.914978f, -205.75766f, 253.443237f, -121.163055f, 187.998413f, -450.820282f);
+            float b2 = (18.92981f);
+            float3x3 r2 = float3x3(323.944763f, 145.672546f, 78.11389f, 466.985168f, -224.687469f, 234.513428f, -140.092865f, 169.0686f, -469.7501f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x3 a3 = float3x3(-248.073364f, 441.5526f, 449.910583f, 354.886047f, 98.82147f, -189.193237f, 269.074829f, -59.11856f, 363.458374f);
+            float b3 = (-26.9960632f);
+            float3x3 r3 = float3x3(-221.0773f, 468.548676f, 476.906647f, 381.8821f, 125.817535f, -162.197174f, 296.0709f, -32.1224976f, 390.454437f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float3x3 b0 = float3x3(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f, -64.233f, -66.04172f, 341.204956f);
+            float3x3 r0 = float3x3(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f, 358.8195f, 360.6282f, -46.61847f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (-385.775055f);
+            float3x3 b1 = float3x3(75.3947754f, 354.943726f, 169.131409f, 88.21661f, 1.73498535f, 122.538025f, -264.945f, -50.83719f, -347.65033f);
+            float3x3 r1 = float3x3(-461.16983f, -740.71875f, -554.9065f, -473.991669f, -387.51004f, -508.31308f, -120.830048f, -334.937866f, -38.1247253f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (4.06555176f);
+            float3x3 b2 = float3x3(-79.09543f, 354.358337f, -292.4925f, -53.2089844f, -246.3476f, 299.203369f, 432.1847f, -163.88f, 176.742554f);
+            float3x3 r2 = float3x3(83.16098f, -350.2928f, 296.558044f, 57.2745361f, 250.413147f, -295.137817f, -428.119141f, 167.945557f, -172.677f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (-104.98584f);
+            float3x3 b3 = float3x3(-445.797638f, -28.8731689f, -169.588226f, -270.359253f, 68.04761f, -65.53128f, 440.380371f, 427.360657f, -81.47296f);
+            float3x3 r3 = float3x3(340.8118f, -76.11267f, 64.60239f, 165.373413f, -173.033447f, -39.45456f, -545.3662f, -532.3465f, -23.5128784f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mul_wide_wide()
+        {
+            float3x3 a0 = float3x3(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f, 494.688477f, 53.5379639f, -239.4964f);
+            float3x3 b0 = float3x3(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f, 207.732422f, 366.192871f, 358.880737f);
+            float3x3 r0 = float3x3(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f, 102762.836f, 19605.22f, -85950.64f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x3 a1 = float3x3(236.675842f, -211.8562f, -216.654816f, 467.9583f, -178.021912f, -386.394257f, -422.4354f, 464.589539f, -251.315674f);
+            float3x3 b1 = float3x3(214.853577f, 253.422791f, -307.7138f, 184.47113f, 426.436462f, -144.281433f, 459.4796f, -358.313354f, -201.3652f);
+            float3x3 r1 = float3x3(50850.6523f, -53689.19f, 66667.68f, 86324.8f, -75915.03f, 55749.5156f, -194100.453f, -166468.641f, 50606.23f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x3 a2 = float3x3(-104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f, -83.11417f, 329.960266f, -316.972168f);
+            float3x3 b2 = float3x3(254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f, -189.746918f, -35.5184631f, 120.31665f);
+            float3x3 r2 = float3x3(-26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f, 15770.6572f, -11719.6816f, -38137.03f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x3 a3 = float3x3(474.937927f, -445.109161f, -301.003723f, 405.687866f, 142.373474f, -416.213074f, -103.279205f, -52.9519043f, -40.82834f);
+            float3x3 b3 = float3x3(-136.203339f, 407.3416f, 301.6543f, -155.482391f, -461.394562f, 296.680359f, 341.001831f, -257.0968f, 17.5936279f);
+            float3x3 r3 = float3x3(-64688.1328f, -181311.484f, -90799.07f, -63077.32f, -65690.34f, -123482.242f, -35218.4f, 13613.7656f, -718.3186f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mul_wide_scalar()
+        {
+            float3x3 a0 = float3x3(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f, -477.3105f, -438.272919f, -46.729187f);
+            float b0 = (192.211182f);
+            float3x3 r0 = float3x3(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f, -91744.4141f, -84240.95f, -8981.872f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x3 a1 = float3x3(-238.405f, -48.83484f, 355.30835f, 119.356628f, -196.995819f, 98.23602f, -325.552155f, 53.9373169f, -87.45099f);
+            float b1 = (422.08252f);
+            float3x3 r1 = float3x3(-100626.586f, -20612.332f, 149969.438f, 50378.3477f, -83148.49f, 41463.707f, -137409.875f, 22765.998f, -36911.5352f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x3 a2 = float3x3(-130.474121f, 126.015015f, 293.361084f, 174.381958f, -327.120056f, 56.62915f, 257.541565f, -475.6087f, -452.6919f);
+            float b2 = (-222.594574f);
+            float3x3 r2 = float3x3(29042.832f, -28050.2578f, -65300.5859f, -38816.4766f, 72815.15f, -12605.3418f, -57327.3555f, 105867.914f, 100766.758f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x3 a3 = float3x3(-49.22061f, 431.5857f, 180.355164f, -40.9234619f, 279.543518f, 120.014465f, -59.508667f, 319.489868f, -403.523163f);
+            float b3 = (141.600952f);
+            float3x3 r3 = float3x3(-6969.68555f, 61112.9453f, 25538.4629f, -5794.80127f, 39583.63f, 16994.1621f, -8426.484f, 45240.07f, -57139.2656f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float3x3 b0 = float3x3(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f, 159.748108f, -351.8222f, 491.801575f);
+            float3x3 r0 = float3x3(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f, -74208.54f, 163433.625f, -228458.891f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (49.90204f);
+            float3x3 b1 = float3x3(424.4626f, 160.1181f, -395.9921f, 125.20166f, -265.0158f, 314.656128f, -292.712036f, -37.72989f, 165.362244f);
+            float3x3 r1 = float3x3(21181.5488f, 7990.21973f, -19760.8125f, 6247.818f, -13224.8291f, 15701.9824f, -14606.9277f, -1882.79834f, 8251.913f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (356.517761f);
+            float3x3 b2 = float3x3(-188.813324f, 504.9157f, 40.5721436f, -206.775116f, -61.60269f, 118.971619f, 53.7483521f, -198.6694f, 96.236084f);
+            float3x3 r2 = float3x3(-67315.3047f, 180011.422f, 14464.6895f, -73719f, -21962.4531f, 42415.4961f, 19162.2422f, -70829.17f, 34309.875f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (-20.2418823f);
+            float3x3 b3 = float3x3(-31.1239624f, 38.89044f, -13.1333008f, 507.871277f, 95.0179443f, 340.7486f, 438.986877f, -227.165955f, 452.573f);
+            float3x3 r3 = float3x3(630.007568f, -787.215759f, 265.842743f, -10280.2705f, -1923.342f, -6897.393f, -8885.921f, 4598.2666f, -9160.93f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_div_wide_wide()
+        {
+            float3x3 a0 = float3x3(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f, 360.41864f, 25.8097534f, -274.050476f);
+            float3x3 b0 = float3x3(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f, -93.2107849f, -442.005219f, 484.362732f);
+            float3x3 r0 = float3x3(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f, -0.565795958f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x3 a1 = float3x3(127.538574f, -447.671753f, -137.458588f, -136.133179f, 12.4376221f, 228.513f, 356.972351f, -24.7620544f, 411.6684f);
+            float3x3 b1 = float3x3(-390.7818f, 402.02533f, 316.6507f, 397.154419f, -303.2622f, -118.591248f, -81.6503f, -84.34686f, -488.419434f);
+            float3x3 r1 = float3x3(-0.326367736f, -1.11354113f, -0.434101641f, -0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f, 0.2935741f, -0.8428584f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x3 a2 = float3x3(-204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f, 315.37384f, -122.665985f, 447.526123f);
+            float3x3 b2 = float3x3(404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f, -218.209686f, 458.517517f, 119.587219f);
+            float3x3 r2 = float3x3(-0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f, -1.44527888f, -0.267527372f, 3.742257f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x3 a3 = float3x3(-210.4815f, -202.42157f, -453.007935f, 173.72699f, -167.121674f, -106.234528f, 414.312561f, 7.12084961f, 274.073669f);
+            float3x3 b3 = float3x3(356.240417f, -74.50687f, -336.773926f, -216.126312f, 322.385681f, 220.2555f, -67.2345f, 2.229187f, -166.210968f);
+            float3x3 r3 = float3x3(-0.5908412f, 2.71681762f, 1.34513962f, -0.803821564f, -0.5183905f, -0.482324064f, -6.16220236f, 3.19437075f, -1.64895058f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_div_wide_scalar()
+        {
+            float3x3 a0 = float3x3(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f, 131.526611f, -261.8864f, -348.9238f);
+            float b0 = (-60.0243835f);
+            float3x3 r0 = float3x3(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f, -2.19121981f, 4.36300039f, 5.813034f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x3 a1 = float3x3(-275.5387f, 287.6424f, 504.372253f, 491.7871f, -26.6315918f, -253.236664f, 272.895142f, 178.096191f, -460.87558f);
+            float b1 = (210.557922f);
+            float3x3 r1 = float3x3(-1.30861235f, 1.36609626f, 2.39540863f, 2.335638f, -0.126481071f, -1.20269358f, 1.29605734f, 0.8458299f, -2.18883038f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x3 a2 = float3x3(-502.646027f, -174.690338f, 83.7963257f, 197.042053f, 317.168274f, 403.387146f, 81.6464844f, 60.6068726f, -413.5605f);
+            float b2 = (-84.3248f);
+            float3x3 r2 = float3x3(5.9608326f, 2.07163668f, -0.99373287f, -2.33670354f, -3.76126933f, -4.783731f, -0.9682381f, -0.7187313f, 4.90437555f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x3 a3 = float3x3(207.341f, 20.7490845f, -68.57712f, 310.702454f, 417.4049f, 147.866211f, 506.658875f, -435.778564f, 210.672913f);
+            float b3 = (358.562134f);
+            float3x3 r3 = float3x3(0.578256845f, 0.05786747f, -0.191255882f, 0.8665233f, 1.16410756f, 0.412386566f, 1.41302955f, -1.21535015f, 0.587549269f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float3x3 b0 = float3x3(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f, 333.6645f, 38.2910767f, -472.979767f);
+            float3x3 r0 = float3x3(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f, 0.125088736f, 1.0900104f, -0.0882440954f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (192.230164f);
+            float3x3 b1 = float3x3(-200.296875f, -490.181519f, -211.10257f, -322.852356f, -137.985291f, 84.32971f, 355.063477f, 276.427246f, -382.988037f);
+            float3x3 r1 = float3x3(-0.9597262f, -0.3921612f, -0.9106008f, -0.595412f, -1.39312065f, 2.279507f, 0.5413966f, 0.6954096f, -0.501922131f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (-488.647156f);
+            float3x3 b2 = float3x3(344.846f, 168.85498f, -44.1955872f, 420.55072f, -175.6152f, -9.220581f, -344.194275f, -449.0715f, 117.704895f);
+            float3x3 r2 = float3x3(-1.417001f, -2.89388657f, 11.056469f, -1.1619221f, 2.78248787f, 52.995266f, 1.41968417f, 1.08812773f, -4.15146f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-337.0274f);
+            float3x3 b3 = float3x3(239.393433f, -389.355164f, 242.716064f, 496.2765f, 91.74579f, -490.492126f, 485.755432f, -317.572266f, -451.6248f);
+            float3x3 r3 = float3x3(-1.407839f, 0.865604043f, -1.38856649f, -0.6791122f, -3.67349172f, 0.6871209f, -0.6938212f, 1.06126213f, 0.746255338f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mod_wide_wide()
+        {
+            float3x3 a0 = float3x3(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f);
+            float3x3 b0 = float3x3(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f, 487.0462f, -469.8291f, -145.203766f);
+            float3x3 r0 = float3x3(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x3 a1 = float3x3(183.44696f, -463.368378f, 83.83911f, -64.71405f, 295.066833f, 212.25708f, 349.6283f, 119.875916f, -37.8058167f);
+            float3x3 b1 = float3x3(-203.384f, -22.52008f, 224.69f, -435.62674f, 12.0955811f, 40.3787842f, 345.784851f, -433.471252f, -355.649963f);
+            float3x3 r1 = float3x3(183.44696f, -12.9667664f, 83.83911f, -64.71405f, 4.772888f, 10.3631592f, 3.84344482f, 119.875916f, -37.8058167f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x3 a2 = float3x3(142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f, 156.985718f, 507.6183f, 270.830444f);
+            float3x3 b2 = float3x3(4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f, -131.4183f, -473.9876f, 76.2178345f);
+            float3x3 r2 = float3x3(1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f, 25.5674133f, 33.6306763f, 42.17694f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x3 a3 = float3x3(337.7343f, 384.915833f, 432.5182f, 154.292725f, -37.0853271f, 7.76147461f, 238.094727f, 12.8520508f, -100.240662f);
+            float3x3 b3 = float3x3(92.2102051f, -368.189575f, -77.46716f, 135.230591f, 274.277283f, 132.180237f, -179.877319f, 51.9685669f, 367.214233f);
+            float3x3 r3 = float3x3(61.1037f, 16.7262573f, 45.182373f, 19.0621338f, -37.0853271f, 7.76147461f, 58.2174072f, 12.8520508f, -100.240662f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mod_wide_scalar()
+        {
+            float3x3 a0 = float3x3(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f, -450.807678f, 186.094788f, -84.47363f);
+            float b0 = (-90.49924f);
+            float3x3 r0 = float3x3(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f, -88.81073f, 5.09631348f, -84.47363f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x3 a1 = float3x3(-318.7815f, -54.60019f, -172.338867f, -429.714661f, 222.361877f, 5.79638672f, 254.5108f, -433.0937f, -203.082611f);
+            float b1 = (433.4547f);
+            float3x3 r1 = float3x3(-318.7815f, -54.60019f, -172.338867f, -429.714661f, 222.361877f, 5.79638672f, 254.5108f, -433.0937f, -203.082611f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x3 a2 = float3x3(-75.3564148f, -69.4039f, 5.337219f, -279.060425f, 483.5506f, -331.993347f, 336f, 67.8396f, -124.720764f);
+            float b2 = (252.289124f);
+            float3x3 r2 = float3x3(-75.3564148f, -69.4039f, 5.337219f, -26.7713013f, 231.261475f, -79.70422f, 83.71088f, 67.8396f, -124.720764f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x3 a3 = float3x3(38.1759033f, 405.773621f, -194.761444f, 235.724f, 465.984863f, -304.153168f, -295.520264f, 313.7224f, -232.202637f);
+            float b3 = (271.287f);
+            float3x3 r3 = float3x3(38.1759033f, 134.486633f, -194.761444f, 235.724f, 194.697876f, -32.86618f, -24.2332764f, 42.4354248f, -232.202637f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float3x3 b0 = float3x3(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f, 397.0448f, -393.890656f, -372.067078f);
+            float3x3 r0 = float3x3(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f, -396.4224f, -2.53173828f, -24.3553162f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (201.012268f);
+            float3x3 b1 = float3x3(-95.566864f, -258.951477f, 106.983582f, 469.323547f, -34.80899f, 184.836548f, 374.79425f, -131.872711f, -120.092865f);
+            float3x3 r1 = float3x3(9.87854f, 201.012268f, 94.02869f, 201.012268f, 26.9673157f, 16.17572f, 201.012268f, 69.13956f, 80.9194f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (4.506653f);
+            float3x3 b2 = float3x3(-111.401947f, 391.54248f, -218.668884f, 196.377441f, -511.032623f, 499.9535f, -433.523071f, -163.866852f, 177.004028f);
+            float3x3 r2 = float3x3(4.506653f, 4.506653f, 4.506653f, 4.506653f, 4.506653f, 4.506653f, 4.506653f, 4.506653f, 4.506653f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (110.650146f);
+            float3x3 b3 = float3x3(17.68457f, -95.85297f, -432.440979f, 192.692078f, -268.131775f, 271.075134f, 423.7027f, -413.233246f, 127.956238f);
+            float3x3 r3 = float3x3(4.54272461f, 14.79718f, 110.650146f, 110.650146f, 110.650146f, 110.650146f, 110.650146f, 110.650146f, 110.650146f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_plus()
+        {
+            float3x3 a0 = float3x3(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f);
+            float3x3 r0 = float3x3(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float3x3 a1 = float3x3(102.054382f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f);
+            float3x3 r1 = float3x3(102.054382f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float3x3 a2 = float3x3(-230.052673f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f, 473.803162f, 285.80896f);
+            float3x3 r2 = float3x3(-230.052673f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f, 473.803162f, 285.80896f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float3x3 a3 = float3x3(-273.2638f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f, -29.0835266f);
+            float3x3 r3 = float3x3(-273.2638f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f, -29.0835266f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_neg()
+        {
+            float3x3 a0 = float3x3(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f, -495.837952f, -270.859467f, 19.68689f);
+            float3x3 r0 = float3x3(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f, 495.837952f, 270.859467f, -19.68689f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float3x3 a1 = float3x3(268.2367f, 223.381287f, -410.392059f, -395.681549f, -349.149475f, -110.9393f, -238.2196f, 292.543518f, 469.2926f);
+            float3x3 r1 = float3x3(-268.2367f, -223.381287f, 410.392059f, 395.681549f, 349.149475f, 110.9393f, 238.2196f, -292.543518f, -469.2926f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float3x3 a2 = float3x3(48.29071f, 66.1485f, 55.7080078f, 464.541382f, 499.2428f, 175.015015f, 196.387573f, -306.1656f, 149.660034f);
+            float3x3 r2 = float3x3(-48.29071f, -66.1485f, -55.7080078f, -464.541382f, -499.2428f, -175.015015f, -196.387573f, 306.1656f, -149.660034f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float3x3 a3 = float3x3(320.391724f, 22.0384521f, -159.55426f, 419.822449f, 303.323425f, 363.716736f, 280.887878f, -270.6513f, -201.615753f);
+            float3x3 r3 = float3x3(-320.391724f, -22.0384521f, 159.55426f, -419.822449f, -303.323425f, -363.716736f, -280.887878f, 270.6513f, 201.615753f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_prefix_inc()
+        {
+            float3x3 a0 = float3x3(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f, -323.614868f, -456.8903f, -76.50766f);
+            float3x3 r0 = float3x3(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f, -322.614868f, -455.8903f, -75.50766f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float3x3 a1 = float3x3(-305.584778f, 148.679321f, 363.2849f, -115.559235f, -326.8778f, -179.894653f, 339.8766f, -38.41043f, -153.373688f);
+            float3x3 r1 = float3x3(-304.584778f, 149.679321f, 364.2849f, -114.559235f, -325.8778f, -178.894653f, 340.8766f, -37.41043f, -152.373688f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float3x3 a2 = float3x3(261.625549f, -396.650238f, 301.3058f, -221.355408f, -429.698151f, -271.2893f, -264.380066f, -377.5592f, 223.232422f);
+            float3x3 r2 = float3x3(262.625549f, -395.650238f, 302.3058f, -220.355408f, -428.698151f, -270.2893f, -263.380066f, -376.5592f, 224.232422f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float3x3 a3 = float3x3(-71.076355f, 131.283142f, 22.3049316f, -480.760468f, 200.951782f, 117.9541f, 139.525818f, 335.6897f, 162.6615f);
+            float3x3 r3 = float3x3(-70.076355f, 132.283142f, 23.3049316f, -479.760468f, 201.951782f, 118.9541f, 140.525818f, 336.6897f, 163.6615f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_postfix_inc()
+        {
+            float3x3 a0 = float3x3(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f);
+            float3x3 r0 = float3x3(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float3x3 a1 = float3x3(-174.173f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f);
+            float3x3 r1 = float3x3(-174.173f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float3x3 a2 = float3x3(454.488831f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f, 417.7298f, 25.5656738f);
+            float3x3 r2 = float3x3(454.488831f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f, 417.7298f, 25.5656738f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float3x3 a3 = float3x3(-463.725647f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f, 64.57703f);
+            float3x3 r3 = float3x3(-463.725647f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f, 64.57703f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_prefix_dec()
+        {
+            float3x3 a0 = float3x3(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f, 337.968933f, 246.088989f, 171.964539f);
+            float3x3 r0 = float3x3(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f, 336.968933f, 245.088989f, 170.964539f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float3x3 a1 = float3x3(-227.44281f, 326.5078f, 400.7209f, -478.031372f, -326.452972f, -24.5845032f, 112.796875f, -341.9763f, -503.27417f);
+            float3x3 r1 = float3x3(-228.44281f, 325.5078f, 399.7209f, -479.031372f, -327.452972f, -25.5845032f, 111.796875f, -342.9763f, -504.27417f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float3x3 a2 = float3x3(-79.6352539f, 147.893677f, -15.7086487f, 188.758423f, 307.791931f, -406.667725f, 181.4751f, -188.69223f, -505.2157f);
+            float3x3 r2 = float3x3(-80.6352539f, 146.893677f, -16.7086487f, 187.758423f, 306.791931f, -407.667725f, 180.4751f, -189.69223f, -506.2157f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float3x3 a3 = float3x3(-372.241943f, 83.76776f, -30.6314087f, -436.906555f, -51.668396f, 345.021545f, 4.73535156f, -68.65332f, 481.4961f);
+            float3x3 r3 = float3x3(-373.241943f, 82.76776f, -31.6314087f, -437.906555f, -52.668396f, 344.021545f, 3.73535156f, -69.65332f, 480.4961f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x3_operator_postfix_dec()
+        {
+            float3x3 a0 = float3x3(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f);
+            float3x3 r0 = float3x3(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float3x3 a1 = float3x3(450.1281f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f);
+            float3x3 r1 = float3x3(450.1281f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float3x3 a2 = float3x3(-357.0542f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f, 409.222473f, -428.2567f);
+            float3x3 r2 = float3x3(-357.0542f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f, 409.222473f, -428.2567f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float3x3 a3 = float3x3(-425.2884f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f, 449.637756f);
+            float3x3 r3 = float3x3(-425.2884f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f, 449.637756f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..15fc4b7046895e0e7cf86610757d47447b219c3f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 27c6e6d3cc1ef6643995a494e7e3b0d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..62a5ce997a41c7d60bf627c42018dba39f349fc0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs
@@ -0,0 +1,949 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat3x4
+    {
+        [TestCompiler]
+        public static void float3x4_zero()
+        {
+            TestUtils.AreEqual(float3x4.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c1.z, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c2.x, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c2.y, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c2.z, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c3.x, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c3.y, 0.0f);
+            TestUtils.AreEqual(float3x4.zero.c3.z, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_equal_wide_wide()
+        {
+            float3x4 a0 = float3x4(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f, 177.924438f, 335.5334f, 168.15448f, 350.729553f, 367.178467f, 46.9414673f);
+            float3x4 b0 = float3x4(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f, -72.44382f, 362.97644f, 194.678345f, 471.644836f, -404.044678f, -144.696747f);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x4 a1 = float3x4(188.76416f, -97.2113953f, -293.320984f, -234.822937f, 417.0337f, 26.3864136f, 269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f);
+            float3x4 b1 = float3x4(-494.446655f, -252.970367f, 234.417114f, 398.724f, 260.4287f, 370.144226f, 89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x4 a2 = float3x4(-22.98944f, 487.260864f, -419.731964f, 337.2033f, 245.043884f, 390.215881f, 84.4129639f, 434.2079f, -68.7284241f, 485.769958f, 413.169739f, -418.2693f);
+            float3x4 b2 = float3x4(-174.081818f, 395.101135f, 350.3393f, -243.144592f, -416.397369f, 151.576477f, -18.2243347f, -431.677917f, -468.330963f, 429.495728f, 477.389221f, -433.4254f);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x4 a3 = float3x4(-346.795868f, 504.159668f, 345.186279f, -434.713043f, -499.7741f, 282.019043f, 259.15625f, 306.455933f, 435.2254f, -386.8997f, 211.364014f, -7.229828f);
+            float3x4 b3 = float3x4(273.5464f, -34.9762268f, 221.968445f, 85.91913f, -85.59894f, 392.7608f, -117.924072f, -445.3056f, -242.468964f, 173.643066f, 389.897766f, -14.2904663f);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_equal_wide_scalar()
+        {
+            float3x4 a0 = float3x4(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f, 314.671265f, 386.365173f, 290.04895f, -132.6352f, -65.66748f, -69.68326f);
+            float b0 = (-155.815765f);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float3x4 a1 = float3x4(-191.190765f, -232.895691f, -319.144043f, -49.70108f, -300.8819f, 333.396851f, 386.3775f, -296.7019f, -309.1172f, 141.542358f, -227.323334f, 83.87286f);
+            float b1 = (186.845215f);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float3x4 a2 = float3x4(-410.91687f, -390.103577f, 36.57434f, -427.541443f, -268.170837f, 175.8117f, -193.47995f, 291.051941f, 423.97168f, -429.8739f, -275.156952f, -56.3323669f);
+            float b2 = (110.501282f);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float3x4 a3 = float3x4(-95.83597f, 253.006165f, -300.509521f, 314.866516f, 195.616211f, -26.1289063f, -284.7747f, -242.672058f, 140.3606f, 505.644348f, 506.537964f, -502.3698f);
+            float b3 = (-124.865326f);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float3x4 b0 = float3x4(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f, 428.311951f, -489.501343f, -5.691559f, -30.8659363f, -362.9831f, 184.503174f);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (-160.470612f);
+            float3x4 b1 = float3x4(316.668823f, 390.369263f, 505.1051f, -294.6487f, 443.1991f, 96.5592651f, -257.012939f, -245.054962f, 326.464844f, -23.9599f, -168.694885f, 386.2486f);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (-227.090637f);
+            float3x4 b2 = float3x4(-336.612427f, 365.108154f, -405.390839f, -473.995483f, 298.435364f, -149.86322f, 450.0664f, 153.47644f, 56.28778f, 39.3421021f, -350.403717f, -482.717224f);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (239.9654f);
+            float3x4 b3 = float3x4(-3.40603638f, -1.49484253f, 105.960449f, 151.537537f, 63.2832031f, -289.693176f, 137.553772f, -247.666473f, -339.420563f, 23.2382813f, 21.1778564f, 477.03656f);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_not_equal_wide_wide()
+        {
+            float3x4 a0 = float3x4(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f, 366.081543f, 154.542847f, 332.4262f, 397.11322f, -431.374969f, 489.0108f);
+            float3x4 b0 = float3x4(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f, -457.730225f, -59.5232544f, 3.024231f, 155.812744f, -19.8399048f, -6.01693726f);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x4 a1 = float3x4(398.4336f, -489.817932f, 171.4049f, -67.82968f, -192.278717f, 227.84082f, 62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f);
+            float3x4 b1 = float3x4(-406.207916f, -102.420715f, -40.362915f, 452.6754f, 93.25757f, -258.378052f, -184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x4 a2 = float3x4(-72.20682f, 444.749268f, 238.81781f, 365.1801f, -437.9229f, -362.442627f, 445.954346f, -0.417480469f, -506.828369f, 245.477051f, -173.571045f, 390.338562f);
+            float3x4 b2 = float3x4(415.071716f, -467.726135f, -433.784668f, -212.165924f, 474.674927f, 452.483215f, -92.11273f, -385.9221f, 420.2151f, -239.176056f, -99.0791f, 4.476013f);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x4 a3 = float3x4(252.837769f, 47.8658447f, 457.7105f, -313.22113f, 391.203857f, 481.786133f, 26.8878174f, -298.1424f, 240.077454f, -332.455139f, -333.607178f, -313.1897f);
+            float3x4 b3 = float3x4(264.348572f, 451.312317f, 232.958008f, -142.6222f, -300.2256f, 268.333252f, -112.103546f, -270.494019f, -71.9932251f, 99.46326f, 321.7033f, 200.059631f);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_not_equal_wide_scalar()
+        {
+            float3x4 a0 = float3x4(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f, -58.92328f, -398.176849f, 492.20105f, -165.241516f, 270.341f, -380.243256f);
+            float b0 = (-393.413544f);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float3x4 a1 = float3x4(501.899048f, 458.400452f, 46.7709961f, 161.459961f, 261.514221f, -145.6124f, -0.449920654f, 350.461426f, 202.221008f, 242.664f, 382.677063f, -468.967957f);
+            float b1 = (-134.345459f);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float3x4 a2 = float3x4(-497.459473f, -328.587769f, -506.490326f, 449.348145f, 210.771f, 249.181824f, -338.468536f, 229.670654f, -76.5433044f, 317.286072f, 401.939575f, 210.984863f);
+            float b2 = (-80.93225f);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float3x4 a3 = float3x4(-147.096313f, 207.731384f, 284.3921f, -509.0853f, 414.307617f, -52.2944641f, -140.437927f, -316.787781f, -358.696838f, 312.31897f, 270.629456f, -140.016724f);
+            float b3 = (-193.399048f);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float3x4 b0 = float3x4(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f, -338.100128f, -152.314545f, -452.820679f, 209.439331f, 50.10797f, 372.4344f);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-488.0213f);
+            float3x4 b1 = float3x4(489.740784f, 270.4001f, -472.846771f, -286.850464f, -384.691864f, 443.423523f, 358.7472f, -15.4140625f, -342.179169f, 468.967529f, -130.568085f, 401.785828f);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (-268.352264f);
+            float3x4 b2 = float3x4(-239.231018f, 411.386536f, 139.769348f, 334.522034f, -223.629242f, -12.4884644f, 113.468872f, -189.652252f, -212.846558f, 306.1256f, -178.330383f, 382.141968f);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (-340.8656f);
+            float3x4 b3 = float3x4(-17.58023f, -409.874847f, -349.70166f, 275.8543f, -229.371948f, -127.505737f, 90.75342f, -422.087128f, -2.44754028f, -280.5517f, -484.374359f, -33.7634277f);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_wide_wide()
+        {
+            float3x4 a0 = float3x4(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f, 3.38293457f, -144.301331f, -69.3696f, -135.667969f, -194.787354f, -33.473877f);
+            float3x4 b0 = float3x4(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f, 231.906311f, 179.49884f, 473.2249f, 15.8916626f, 270.049927f, 490.914f);
+            bool3x4 r0 = bool3x4(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x4 a1 = float3x4(-19.67508f, 423.237976f, -71.6983f, -501.886f, 7.64386f, 302.262878f, -140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f);
+            float3x4 b1 = float3x4(-185.734131f, 76.4331055f, 97.75232f, 419.300781f, 73.953186f, 481.032349f, 7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x4 a2 = float3x4(269.1078f, 462.98822f, 223.884155f, -287.18924f, 283.6386f, 511.864319f, -60.4967957f, -234.303467f, -316.1384f, -417.522156f, 441.643433f, -191.950623f);
+            float3x4 b2 = float3x4(-382.315857f, 251.535156f, 143.17395f, 293.660339f, -292.769562f, -43.2182f, -353.4112f, 458.32605f, -114.556458f, 441.429749f, -113.333679f, 435.622925f);
+            bool3x4 r2 = bool3x4(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x4 a3 = float3x4(397.811584f, -144.666626f, 417.079041f, -322.980133f, -81.2850952f, 319.325317f, 146.764038f, -316.583374f, -150.857544f, -314.606323f, 7.14312744f, -458.8273f);
+            float3x4 b3 = float3x4(383.656128f, -293.7116f, -391.35498f, 43.12201f, 433.223633f, -201.382446f, -241.421173f, 376.469849f, -503.39743f, -359.780945f, 118.631531f, -510.030518f);
+            bool3x4 r3 = bool3x4(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_wide_scalar()
+        {
+            float3x4 a0 = float3x4(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f, 282.9666f, 258.2791f, -111.413147f, -288.081116f, 82.6654053f, -361.6429f);
+            float b0 = (199.0675f);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float3x4 a1 = float3x4(-68.0881958f, -66.703064f, -78.76297f, 25.7277222f, 101.37085f, -330.442657f, -48.9205322f, 359.604431f, -8.150085f, 241.2768f, -183.437775f, 423.027161f);
+            float b1 = (12.7880249f);
+            bool3x4 r1 = bool3x4(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float3x4 a2 = float3x4(-334.622742f, 300.410156f, 297.925232f, -492.108154f, -395.807251f, 95.78882f, -220.62146f, -455.37558f, 360.291565f, -296.372131f, 272.488342f, 360.207947f);
+            float b2 = (-98.31558f);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float3x4 a3 = float3x4(389.727417f, -400.615234f, -85.46912f, -467.702148f, -51.38788f, 201.764648f, -47.8412781f, -180.740051f, -409.0157f, 229.699036f, 176.197876f, -410.45517f);
+            float b3 = (68.7366943f);
+            bool3x4 r3 = bool3x4(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float3x4 b0 = float3x4(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f, -299.744324f, 31.4371338f, -458.904541f, 13.6846924f, -458.5069f, 248.276489f);
+            bool3x4 r0 = bool3x4(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (389.231445f);
+            float3x4 b1 = float3x4(488.745544f, -221.637878f, -424.2672f, 249.059021f, -22.1361389f, -442.247742f, -340.857544f, -95.1117249f, 15.4094238f, 87.29248f, 495.067627f, 316.0185f);
+            bool3x4 r1 = bool3x4(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (-125.568115f);
+            float3x4 b2 = float3x4(122.164795f, 96.75537f, -228.906342f, -143.9527f, -230.238281f, -327.6126f, 103.39801f, 434.488831f, -157.4502f, 190.572144f, 108.2583f, 132.550781f);
+            bool3x4 r2 = bool3x4(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-431.515228f);
+            float3x4 b3 = float3x4(-192.203522f, -431.835f, -85.58124f, 328.670532f, 273.577881f, -178.669067f, 352.6363f, -82.6058044f, 238.908875f, 291.335327f, 183.357361f, -185.0326f);
+            bool3x4 r3 = bool3x4(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_wide_wide()
+        {
+            float3x4 a0 = float3x4(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f, -396.770355f, 127.037415f, 489.1399f, 51.9188843f, 155.384766f, -135.631653f);
+            float3x4 b0 = float3x4(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f, -391.096039f, 479.283752f, -77.6748657f, -46.584198f, -415.377f, 71.46698f);
+            bool3x4 r0 = bool3x4(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x4 a1 = float3x4(-425.978149f, -228.430511f, 383.03833f, 136.533569f, 8.602417f, -251.324371f, -345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f);
+            float3x4 b1 = float3x4(-206.061035f, 360.8363f, 236.968811f, 14.550354f, 364.735168f, -159.06131f, 226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x4 a2 = float3x4(105.535217f, -170.9253f, 26.9802246f, -188.928314f, 201.786621f, -506.057159f, 15.454895f, 115.080688f, -496.971832f, 339.888123f, 372.228333f, 313.2387f);
+            float3x4 b2 = float3x4(-352.1598f, 9.822632f, 186.721619f, -325.913635f, -77.93036f, -379.746033f, 251.45575f, -144.183563f, 337.8899f, -249.505554f, -225.9013f, -249.491272f);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x4 a3 = float3x4(-419.108948f, -265.329773f, -42.5019836f, 369.163879f, 67.16907f, -256.6989f, -104.105927f, 499.570129f, 41.6635132f, 151.1521f, 220.688354f, -344.658875f);
+            float3x4 b3 = float3x4(381.122864f, 325.5454f, 455.49884f, 333.318665f, 118.980347f, 223.19812f, -385.289063f, 333.8808f, -437.4107f, 243.975464f, -302.8199f, -32.7101746f);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_wide_scalar()
+        {
+            float3x4 a0 = float3x4(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f, 173.575073f, 69.26929f, 501.306824f, -367.027771f, -86.12451f, -489.090576f);
+            float b0 = (-302.816956f);
+            bool3x4 r0 = bool3x4(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float3x4 a1 = float3x4(-172.518158f, -236.414948f, -238.8945f, -27.2391357f, 471.779358f, 240.164551f, -481.4781f, 185.59436f, 33.29474f, -510.228149f, -183.2862f, -386.127655f);
+            float b1 = (-18.1496277f);
+            bool3x4 r1 = bool3x4(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float3x4 a2 = float3x4(-13.6382141f, -261.865967f, 52.24951f, 16.3232422f, -410.5101f, -262.2675f, -458.255981f, -218.866119f, -34.6923523f, 290.573059f, 180.2633f, -482.863953f);
+            float b2 = (-7.34790039f);
+            bool3x4 r2 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float3x4 a3 = float3x4(100.7063f, 501.319763f, -289.280975f, -25.8497f, 455.1624f, -63.3173523f, -17.4467773f, 53.01776f, 88.81958f, 182.357971f, -428.927216f, 408.336853f);
+            float b3 = (180.672546f);
+            bool3x4 r3 = bool3x4(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float3x4 b0 = float3x4(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f, 176.409241f, -140.440033f, -182.48288f, -158.2933f, -162.685333f, -193.328674f);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (230.181274f);
+            float3x4 b1 = float3x4(-102.58783f, 392.520569f, -177.478668f, -10.2950134f, -24.04895f, 172.448669f, 374.048035f, -368.99762f, -210.195282f, 149.470215f, -281.343262f, -100.469177f);
+            bool3x4 r1 = bool3x4(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (304.864441f);
+            float3x4 b2 = float3x4(-361.524841f, -372.452362f, -33.9095459f, -69.5952759f, -460.4324f, -309.341675f, 486.131531f, 471.920959f, 479.361572f, -107.004181f, 331.636536f, -340.840149f);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (-384.2146f);
+            float3x4 b3 = float3x4(-451.726563f, 467.97876f, -236.569122f, 44.6547241f, -285.797852f, 42.730957f, 338.18512f, 274.017029f, -108.60437f, -211.37326f, -19.00415f, 194.114685f);
+            bool3x4 r3 = bool3x4(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_equal_wide_wide()
+        {
+            float3x4 a0 = float3x4(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f, 294.6701f, -327.564453f, -456.12326f, 282.30127f, 421.881165f, -311.71283f);
+            float3x4 b0 = float3x4(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f, 74.41406f, 260.916138f, 306.173279f, 139.564819f, -505.752472f, -489.6268f);
+            bool3x4 r0 = bool3x4(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x4 a1 = float3x4(84.5675049f, 447.244629f, -154.494354f, -424.364746f, 36.68451f, 267.0703f, 307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f);
+            float3x4 b1 = float3x4(-280.0326f, 303.1599f, 511.1902f, -104.659729f, 95.14661f, -125.636353f, 376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x4 a2 = float3x4(-77.04346f, 438.1848f, 260.282349f, 386.034058f, -281.491f, -102.930054f, -346.716736f, -258.3412f, -383.302948f, -5.14703369f, 319.34375f, 465.022217f);
+            float3x4 b2 = float3x4(-216.002319f, 66.73425f, 99.21863f, 233.843018f, 439.839966f, 61.1151123f, -219.030579f, -404.7129f, -202.748352f, -312.476471f, 310.0719f, -320.363037f);
+            bool3x4 r2 = bool3x4(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x4 a3 = float3x4(145.933472f, -215.074829f, -146.461517f, -349.893982f, 29.5991211f, -131.796631f, -438.9947f, 147.057922f, 221.112488f, -356.145355f, -32.83017f, 442.942017f);
+            float3x4 b3 = float3x4(186.075989f, -42.6377869f, 82.56506f, 127.189087f, 198.286987f, -450.492035f, 20.901001f, 449.465881f, -478.7727f, 380.053955f, 99.1247559f, -450.329773f);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_equal_wide_scalar()
+        {
+            float3x4 a0 = float3x4(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f, -410.870056f, -483.902649f, 183.821167f, 320.4425f, -257.870056f, -386.801758f);
+            float b0 = (292.924255f);
+            bool3x4 r0 = bool3x4(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float3x4 a1 = float3x4(-182.938812f, 485.311584f, 373.5691f, 259.1515f, 450.130066f, -128.525543f, -43.8748779f, 457.385742f, -77.6383057f, 479.451843f, -499.516449f, -398.132935f);
+            float b1 = (349.250122f);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float3x4 a2 = float3x4(402.484863f, -502.1736f, 125.950806f, -54.49362f, 250.667419f, 97.94293f, 228.021545f, -213.378662f, 42.2608032f, -24.8275757f, -451.0416f, 429.577576f);
+            float b2 = (87.91608f);
+            bool3x4 r2 = bool3x4(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float3x4 a3 = float3x4(-308.4343f, -279.4071f, 181.672241f, -290.148743f, -184.844086f, 447.6939f, 168.8866f, 26.3789673f, 392.558533f, 255.604858f, 162.163452f, 195.496277f);
+            float b3 = (355.160339f);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float3x4 b0 = float3x4(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f, 288.5443f, 304.042847f, -148.618073f, -506.3001f, 27.5812378f, 48.47113f);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (104.883484f);
+            float3x4 b1 = float3x4(-488.685852f, -480.435181f, 421.936646f, 239.721069f, -101.018433f, -283.951477f, -55.24353f, -455.80484f, 131.107239f, -461.6988f, -388.482849f, -258.936035f);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-225.223541f);
+            float3x4 b2 = float3x4(-116.019989f, -442.595245f, 297.333374f, 36.6872559f, 485.097839f, 344.445679f, 237.592163f, 230.390869f, -413.9848f, -215.901672f, 39.5603638f, 22.947998f);
+            bool3x4 r2 = bool3x4(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (-162.060577f);
+            float3x4 b3 = float3x4(236.7337f, -253.951965f, -204.719086f, -161.616547f, -64.3859253f, -229.815643f, -484.825653f, -135.040436f, 351.694763f, 111.825378f, -249.982544f, 435.8073f);
+            bool3x4 r3 = bool3x4(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_equal_wide_wide()
+        {
+            float3x4 a0 = float3x4(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f, -122.535187f, 7.48144531f, 152.946411f, 48.9862061f, 57.3381348f, 300.4649f);
+            float3x4 b0 = float3x4(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f, -373.302063f, 364.9359f, -322.7154f, 125.47821f, -25.77658f, 297.518921f);
+            bool3x4 r0 = bool3x4(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x4 a1 = float3x4(349.25708f, 85.7496948f, -230.953308f, 418.711243f, -131.039917f, -126.512207f, -156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f);
+            float3x4 b1 = float3x4(73.22235f, 462.783752f, 393.191345f, -95.0014343f, 381.357056f, 93.03192f, 254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x4 a2 = float3x4(-223.492981f, 302.123f, 459.852722f, -347.128021f, 364.9781f, 212.635437f, 504.276062f, -142.232971f, -132.2218f, 303.683777f, 265.210144f, 9.754395f);
+            float3x4 b2 = float3x4(453.684875f, -154.011658f, -97.29007f, 151.184753f, 57.36029f, -194.207092f, -462.670624f, 113.3866f, -129.3533f, 8.107788f, 426.449524f, 410.693176f);
+            bool3x4 r2 = bool3x4(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x4 a3 = float3x4(-233.0929f, 26.5675049f, 266.7807f, -250.072235f, 138.040833f, 174.276733f, -420.931641f, -42.8541565f, 216.485046f, 240.053833f, -470.382172f, 98.39673f);
+            float3x4 b3 = float3x4(470.313416f, 220.399963f, -372.872681f, -242.178558f, 177.506226f, -172.638153f, 60.72284f, 478.250183f, 234.30304f, 297.821228f, 104.584595f, -462.418732f);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_equal_wide_scalar()
+        {
+            float3x4 a0 = float3x4(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f, 53.8151245f, -123.332947f, -221.505463f, 252.994324f, -116.440369f, -395.3633f);
+            float b0 = (189.205139f);
+            bool3x4 r0 = bool3x4(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float3x4 a1 = float3x4(164.772583f, 355.837036f, 184.195557f, 273.012268f, -418.1424f, 249.3841f, 396.392151f, 332.6654f, 243.761414f, -335.12146f, -302.0869f, 254.442261f);
+            float b1 = (-287.007324f);
+            bool3x4 r1 = bool3x4(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float3x4 a2 = float3x4(179.005066f, -331.271667f, 307.890564f, -388.578522f, 150.605774f, -219.892578f, -491.681f, 30.99707f, 199.232239f, -74.50003f, -343.386475f, 216.031555f);
+            float b2 = (71.1767f);
+            bool3x4 r2 = bool3x4(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float3x4 a3 = float3x4(-420.403137f, -336.6411f, 317.0946f, -262.424927f, -228.411255f, 123.465454f, 264.102478f, 223.623352f, 440.5354f, -420.727f, 74.8443f, -177.077881f);
+            float b3 = (-78.38403f);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float3x4 b0 = float3x4(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f, -455.612579f, 276.665833f, 79.39917f, 416.420532f, 379.2735f, -439.5147f);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (67.14099f);
+            float3x4 b1 = float3x4(-74.56064f, -367.256348f, 494.950745f, -61.2355347f, -429.170258f, -213.824677f, -264.310181f, 243.11377f, -22.38388f, 304.862f, -323.686157f, 67.93805f);
+            bool3x4 r1 = bool3x4(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (125.303589f);
+            float3x4 b2 = float3x4(-400.47052f, -283.159637f, -42.31961f, -429.510376f, 499.395874f, -289.963074f, -136.008789f, -351.125244f, -381.8183f, 393.3009f, 18.02362f, -169.92392f);
+            bool3x4 r2 = bool3x4(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (-285.884949f);
+            float3x4 b3 = float3x4(163.7511f, 191.855347f, 114.0155f, -395.98584f, 189.366577f, 176.19812f, 61.7138062f, 507.548462f, 224.043823f, -422.9937f, -127.054993f, 95.5286255f);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_add_wide_wide()
+        {
+            float3x4 a0 = float3x4(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f, -470.536774f, -109.9501f, -178.701447f, -420.033783f, 290.711121f, -446.529633f);
+            float3x4 b0 = float3x4(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f, 267.49176f, 251.642517f, 244.495117f, -78.67575f, 352.2055f, 82.7791748f);
+            float3x4 r0 = float3x4(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f, -203.045013f, 141.692413f, 65.79367f, -498.709534f, 642.9166f, -363.750458f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x4 a1 = float3x4(491.066467f, -261.1173f, -298.4069f, 502.4286f, 284.5943f, 401.128418f, -36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f);
+            float3x4 b1 = float3x4(462.5473f, -405.492f, -428.498322f, -41.87259f, -269.9275f, 75.20447f, -141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f);
+            float3x4 r1 = float3x4(953.6138f, -666.6093f, -726.9052f, 460.556f, 14.6668091f, 476.3329f, -178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x4 a2 = float3x4(-62.8800049f, -79.5522461f, 413.098267f, -100.877594f, 418.524f, -183.143127f, 407.443726f, 300.486023f, -261.126129f, -309.830353f, 378.363342f, -224.094f);
+            float3x4 b2 = float3x4(492.692444f, 439.043823f, -511.742767f, -399.057129f, -315.868469f, -228.07724f, -171.7052f, 467.17395f, -474.822937f, 311.390747f, 326.8454f, 475.2119f);
+            float3x4 r2 = float3x4(429.812439f, 359.491577f, -98.6445f, -499.934723f, 102.655518f, -411.220367f, 235.738525f, 767.66f, -735.9491f, 1.56039429f, 705.20874f, 251.11792f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x4 a3 = float3x4(-164.555725f, -69.87393f, 224.634644f, -383.9926f, 149.221252f, 169.388f, 163.053955f, 57.0291138f, 342.950073f, 168.680481f, -470.770264f, -117.630493f);
+            float3x4 b3 = float3x4(314.152954f, -262.594635f, -82.86911f, 156.299561f, 427.40155f, -279.099365f, -448.615234f, 284.3371f, 288.1856f, -232.39505f, -386.871918f, 162.903381f);
+            float3x4 r3 = float3x4(149.597229f, -332.468567f, 141.765533f, -227.693054f, 576.6228f, -109.711365f, -285.561279f, 341.3662f, 631.1357f, -63.71457f, -857.6422f, 45.27289f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_add_wide_scalar()
+        {
+            float3x4 a0 = float3x4(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f, -2.79125977f, -478.4148f, 443.115234f, 268.092224f, 41.3210449f, -471.256073f);
+            float b0 = (500.997253f);
+            float3x4 r0 = float3x4(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f, 498.206f, 22.5824585f, 944.1125f, 769.0895f, 542.3183f, 29.74118f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float3x4 a1 = float3x4(-2.664978f, 202.14801f, 311.725464f, 10.3458252f, -151.244446f, 355.2328f, -197.800751f, 255.955261f, 244.1471f, -181.626556f, -2.45492554f, 300.900635f);
+            float b1 = (78.98584f);
+            float3x4 r1 = float3x4(76.32086f, 281.13385f, 390.7113f, 89.331665f, -72.258606f, 434.218628f, -118.814911f, 334.9411f, 323.132935f, -102.640717f, 76.5309143f, 379.886475f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float3x4 a2 = float3x4(-236.491943f, -172.5422f, -242.9411f, 466.344116f, 237.987488f, 264.294f, 372.866821f, -198.837769f, -381.930969f, 402.160339f, -117.024841f, 497.373779f);
+            float b2 = (-160.5841f);
+            float3x4 r2 = float3x4(-397.07605f, -333.1263f, -403.5252f, 305.76f, 77.40338f, 103.7099f, 212.282715f, -359.421875f, -542.5151f, 241.576233f, -277.608948f, 336.789673f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float3x4 a3 = float3x4(485.9093f, 77.81482f, -271.547974f, -133.2518f, 211.86676f, 253.1502f, -342.783173f, -185.248352f, -403.3855f, -358.848236f, 65.24756f, 127.201721f);
+            float b3 = (-47.75714f);
+            float3x4 r3 = float3x4(438.152161f, 30.0576782f, -319.3051f, -181.008942f, 164.109619f, 205.393066f, -390.5403f, -233.0055f, -451.142639f, -406.605377f, 17.4904175f, 79.44458f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float3x4 b0 = float3x4(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f, 180.318115f, 337.579346f, -37.0550232f, 230.805f, -140.174347f, 18.02417f);
+            float3x4 r0 = float3x4(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f, -145.194641f, 12.0665894f, -362.56778f, -94.70776f, -465.6871f, -307.4886f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (-138.614349f);
+            float3x4 b1 = float3x4(26.9041748f, -374.5376f, 154.46759f, 268.38385f, -190.963013f, 188.617249f, -504.916138f, 20.45404f, 197.945374f, 251.411926f, -421.0904f, 111.445374f);
+            float3x4 r1 = float3x4(-111.710175f, -513.152f, 15.853241f, 129.7695f, -329.577362f, 50.0029f, -643.5305f, -118.160309f, 59.3310242f, 112.797577f, -559.7047f, -27.1689758f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (-73.26889f);
+            float3x4 b2 = float3x4(480.884583f, 438.05304f, 66.8443f, -270.796021f, -44.02191f, 197.6947f, 19.1139526f, 349.2378f, 366.2345f, -413.4803f, -260.720184f, 77.54236f);
+            float3x4 r2 = float3x4(407.6157f, 364.784149f, -6.424591f, -344.0649f, -117.2908f, 124.425812f, -54.1549377f, 275.9689f, 292.9656f, -486.749176f, -333.989075f, 4.273468f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (183.9549f);
+            float3x4 b3 = float3x4(-51.4989929f, -472.497467f, 107.126892f, 349.0772f, 431.595947f, -314.110962f, 396.996643f, -167.308624f, -157.114532f, 287.7625f, -367.33905f, 96.23682f);
+            float3x4 r3 = float3x4(132.4559f, -288.542572f, 291.0818f, 533.0321f, 615.550842f, -130.156067f, 580.951538f, 16.64627f, 26.8403625f, 471.7174f, -183.384155f, 280.1917f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_sub_wide_wide()
+        {
+            float3x4 a0 = float3x4(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f, 146.506592f, -130.585052f, 110.7771f, -235.5416f, 78.87933f, -347.686157f);
+            float3x4 b0 = float3x4(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f, -125.6055f, -65.29901f, -477.876434f, 164.5f, 428.009583f, 72.62781f);
+            float3x4 r0 = float3x4(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f, 272.1121f, -65.28604f, 588.653564f, -400.0416f, -349.130249f, -420.313965f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x4 a1 = float3x4(-470.820557f, -11.45929f, -167.9479f, 330.676758f, -508.350861f, -252.031891f, -427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f);
+            float3x4 b1 = float3x4(-446.8805f, 432.091431f, -225.554657f, -112.451965f, -210.6128f, -172.925049f, -80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f);
+            float3x4 r1 = float3x4(-23.9400635f, -443.55072f, 57.60675f, 443.128723f, -297.738068f, -79.10684f, -347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x4 a2 = float3x4(-308.939575f, 454.5334f, 26.1069336f, -482.711823f, -40.8535461f, 318.380676f, 475.210815f, 134.926941f, 388.481567f, 138.7182f, -385.5736f, -149.3648f);
+            float3x4 b2 = float3x4(-221.325439f, -9.25882f, 288.173828f, 217.36145f, 307.540039f, -262.412659f, -405.378021f, 400.004333f, 72.11908f, -154.880585f, -469.659973f, -320.615417f);
+            float3x4 r2 = float3x4(-87.6141357f, 463.7922f, -262.0669f, -700.073242f, -348.3936f, 580.793335f, 880.588867f, -265.0774f, 316.3625f, 293.5988f, 84.0863647f, 171.25061f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x4 a3 = float3x4(-158.534058f, 508.070679f, 482.7008f, 114.569275f, 364.83136f, 229.031f, -168.088074f, 373.4411f, -239.90097f, 379.928467f, 113.011841f, 306.835266f);
+            float3x4 b3 = float3x4(6.41229248f, -278.865051f, 15.8380737f, 27.51831f, 429.869629f, -458.622467f, -172.064423f, -284.524719f, 42.60669f, -223.474243f, -56.92975f, 61.807312f);
+            float3x4 r3 = float3x4(-164.94635f, 786.9357f, 466.862732f, 87.0509644f, -65.03827f, 687.653442f, 3.97634888f, 657.9658f, -282.50766f, 603.4027f, 169.941589f, 245.027954f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_sub_wide_scalar()
+        {
+            float3x4 a0 = float3x4(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f, 204.358337f, 180.269714f, -377.9257f, -470.262054f, 400.5349f, 461.507568f);
+            float b0 = (-291.5904f);
+            float3x4 r0 = float3x4(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f, 495.94873f, 471.8601f, -86.3353f, -178.671661f, 692.1253f, 753.097961f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float3x4 a1 = float3x4(-246.287262f, 246.350708f, -121.427368f, -122.718414f, -122.938721f, 360.15094f, 342.874573f, 18.92981f, 164.602356f, 97.0437f, 485.914978f, -205.75766f);
+            float b1 = (21.6052856f);
+            float3x4 r1 = float3x4(-267.892548f, 224.745422f, -143.032654f, -144.3237f, -144.544f, 338.545654f, 321.2693f, -2.675476f, 142.99707f, 75.4384155f, 464.3097f, -227.362946f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float3x4 a2 = float3x4(253.443237f, 187.998413f, -450.820282f, -248.073364f, -26.9960632f, 441.5526f, 449.910583f, 354.886047f, 98.82147f, -189.193237f, 269.074829f, -59.11856f);
+            float b2 = (-121.163055f);
+            float3x4 r2 = float3x4(374.6063f, 309.161469f, -329.657227f, -126.910309f, 94.16699f, 562.7157f, 571.0736f, 476.0491f, 219.984528f, -68.03018f, 390.237885f, 62.0444946f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float3x4 a3 = float3x4(363.458374f, -46.1552124f, 109.913269f, 182.646912f, 229.015747f, -144.92868f, 469.2506f, -150.49231f, -192.3125f, -224.356842f, 285.876831f, -63.0108337f);
+            float b3 = (-73.7792053f);
+            float3x4 r3 = float3x4(437.237579f, 27.6239929f, 183.692474f, 256.426117f, 302.794952f, -71.1494751f, 543.0298f, -76.7131042f, -118.533295f, -150.577637f, 359.656036f, 10.7683716f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float3x4 b0 = float3x4(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f, -64.233f, -66.04172f, 341.204956f, -385.775055f, 75.3947754f, 354.943726f);
+            float3x4 r0 = float3x4(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f, 358.8195f, 360.6282f, -46.61847f, 680.3616f, 219.191711f, -60.35724f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (169.131409f);
+            float3x4 b1 = float3x4(88.21661f, 1.73498535f, 122.538025f, -264.945f, -50.83719f, -347.65033f, 4.06555176f, -79.09543f, 354.358337f, -292.4925f, -53.2089844f, -246.3476f);
+            float3x4 r1 = float3x4(80.9147949f, 167.396423f, 46.5933838f, 434.076416f, 219.9686f, 516.781738f, 165.065857f, 248.226837f, -185.226929f, 461.6239f, 222.3404f, 415.479f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (299.203369f);
+            float3x4 b2 = float3x4(432.1847f, -163.88f, 176.742554f, -104.98584f, -445.797638f, -28.8731689f, -169.588226f, -270.359253f, 68.04761f, -65.53128f, 440.380371f, 427.360657f);
+            float3x4 r2 = float3x4(-132.981323f, 463.083374f, 122.460815f, 404.1892f, 745.001f, 328.076538f, 468.7916f, 569.5626f, 231.155762f, 364.73465f, -141.177f, -128.157288f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (-81.47296f);
+            float3x4 b3 = float3x4(41.7131958f, 175.8208f, -214.949158f, -163.446869f, -218.829132f, 389.116882f, -74.10977f, -448.137238f, -410.375f, 363.211f, -263.5354f, 473.546021f);
+            float3x4 r3 = float3x4(-123.186157f, -257.293762f, 133.4762f, 81.97391f, 137.356171f, -470.589844f, -7.3631897f, 366.664276f, 328.902039f, -444.68396f, 182.062439f, -555.019f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mul_wide_wide()
+        {
+            float3x4 a0 = float3x4(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f, 494.688477f, 53.5379639f, -239.4964f, 236.675842f, -211.8562f, -216.654816f);
+            float3x4 b0 = float3x4(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f, 207.732422f, 366.192871f, 358.880737f, 214.853577f, 253.422791f, -307.7138f);
+            float3x4 r0 = float3x4(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f, 102762.836f, 19605.22f, -85950.64f, 50850.6523f, -53689.19f, 66667.68f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x4 a1 = float3x4(467.9583f, -178.021912f, -386.394257f, -422.4354f, 464.589539f, -251.315674f, -104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f);
+            float3x4 b1 = float3x4(184.47113f, 426.436462f, -144.281433f, 459.4796f, -358.313354f, -201.3652f, 254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f);
+            float3x4 r1 = float3x4(86324.8f, -75915.03f, 55749.5156f, -194100.453f, -166468.641f, 50606.23f, -26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x4 a2 = float3x4(-83.11417f, 329.960266f, -316.972168f, 474.937927f, -445.109161f, -301.003723f, 405.687866f, 142.373474f, -416.213074f, -103.279205f, -52.9519043f, -40.82834f);
+            float3x4 b2 = float3x4(-189.746918f, -35.5184631f, 120.31665f, -136.203339f, 407.3416f, 301.6543f, -155.482391f, -461.394562f, 296.680359f, 341.001831f, -257.0968f, 17.5936279f);
+            float3x4 r2 = float3x4(15770.6572f, -11719.6816f, -38137.03f, -64688.1328f, -181311.484f, -90799.07f, -63077.32f, -65690.34f, -123482.242f, -35218.4f, 13613.7656f, -718.3186f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x4 a3 = float3x4(-86.18509f, -257.316528f, 363.857239f, -229.860016f, 8.925293f, -2.44940186f, 37.7583f, 264.451782f, -321.251282f, -268.256042f, 43.9136963f, 274.833069f);
+            float3x4 b3 = float3x4(-443.845123f, 291.349243f, 490.19165f, 361.320984f, -509.289734f, 315.352661f, 125.083069f, -167.727112f, 396.8877f, -0.320404053f, 143.4115f, -396.3475f);
+            float3x4 r3 = float3x4(38252.832f, -74968.98f, 178359.781f, -83053.25f, -4545.56f, -772.4254f, 4722.92432f, -44355.7344f, -127500.68f, 85.950325f, 6297.729f, -108929.4f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mul_wide_scalar()
+        {
+            float3x4 a0 = float3x4(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f, -477.3105f, -438.272919f, -46.729187f, -238.405f, 422.08252f, -48.83484f);
+            float b0 = (192.211182f);
+            float3x4 r0 = float3x4(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f, -91744.4141f, -84240.95f, -8981.872f, -45824.1055f, 81128.98f, -9386.603f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float3x4 a1 = float3x4(355.30835f, -196.995819f, 98.23602f, -325.552155f, 53.9373169f, -87.45099f, -130.474121f, -222.594574f, 126.015015f, 293.361084f, 174.381958f, -327.120056f);
+            float b1 = (119.356628f);
+            float3x4 r1 = float3x4(42408.4063f, -23512.7559f, 11725.12f, -38856.81f, 6437.77637f, -10437.8555f, -15572.9512f, -26568.1387f, 15040.7275f, 35014.59f, 20813.6426f, -39043.9453f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float3x4 a2 = float3x4(56.62915f, -475.6087f, -452.6919f, -49.22061f, 141.600952f, 431.5857f, 180.355164f, -40.9234619f, 279.543518f, 120.014465f, -59.508667f, 319.489868f);
+            float b2 = (257.541565f);
+            float3x4 r2 = float3x4(14584.36f, -122489.008f, -116586.977f, -12676.3535f, 36468.13f, 111151.258f, 46448.95f, -10539.4922f, 71994.08f, 30908.7129f, -15325.9551f, 82281.92f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float3x4 a3 = float3x4(-403.523163f, -335.3932f, -364.242554f, 150.686157f, 391.87207f, 179.312439f, 354.5298f, 497.7614f, 418.436584f, -413.333374f, -329.520721f, -322.703064f);
+            float b3 = (-408.1931f);
+            float3x4 r3 = float3x4(164715.375f, 136905.188f, 148681.3f, -61509.05f, -159959.484f, -73194.1f, -144716.625f, -203182.781f, -170802.938f, 168719.844f, 134508.1f, 131725.172f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float3x4 b0 = float3x4(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f, 159.748108f, -351.8222f, 491.801575f, 49.90204f, 424.4626f, 160.1181f);
+            float3x4 r0 = float3x4(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f, -74208.54f, 163433.625f, -228458.891f, -23181.2285f, -197177.6f, -74380.4141f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (-395.9921f);
+            float3x4 b1 = float3x4(125.20166f, -265.0158f, 314.656128f, -292.712036f, -37.72989f, 165.362244f, 356.517761f, -188.813324f, 504.9157f, 40.5721436f, -206.775116f, -61.60269f);
+            float3x4 r1 = float3x4(-49578.8672f, 104944.164f, -124601.336f, 115911.656f, 14940.7373f, -65482.14f, -141178.219f, 74768.5859f, -199942.625f, -16066.248f, 81881.31f, 24394.18f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (118.971619f);
+            float3x4 b2 = float3x4(53.7483521f, -198.6694f, 96.236084f, -20.2418823f, -31.1239624f, 38.89044f, -13.1333008f, 507.871277f, 95.0179443f, 340.7486f, 438.986877f, -227.165955f);
+            float3x4 r2 = float3x4(6394.52832f, -23636.02f, 11449.3623f, -2408.20947f, -3702.86816f, 4626.859f, -1562.49011f, 60422.27f, 11304.4385f, 40539.41f, 52226.98f, -27026.3f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (452.573f);
+            float3x4 b3 = float3x4(144.014954f, -31.58603f, 42.29773f, -466.027161f, 287.453979f, 328.9969f, -164.243134f, -511.2683f, -9.594299f, 431.190125f, -132.141815f, -87.502655f);
+            float3x4 r3 = float3x4(65177.28f, -14294.9834f, 19142.81f, -210911.313f, 130093.906f, 148895.109f, -74332.01f, -231386.234f, -4342.12061f, 195145f, -59803.8164f, -39601.34f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_div_wide_wide()
+        {
+            float3x4 a0 = float3x4(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f, 360.41864f, 25.8097534f, -274.050476f, 127.538574f, -447.671753f, -137.458588f);
+            float3x4 b0 = float3x4(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f, -93.2107849f, -442.005219f, 484.362732f, -390.7818f, 402.02533f, 316.6507f);
+            float3x4 r0 = float3x4(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f, -0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x4 a1 = float3x4(-136.133179f, 12.4376221f, 228.513f, 356.972351f, -24.7620544f, 411.6684f, -204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f);
+            float3x4 b1 = float3x4(397.154419f, -303.2622f, -118.591248f, -81.6503f, -84.34686f, -488.419434f, 404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f);
+            float3x4 r1 = float3x4(-0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f, 0.2935741f, -0.8428584f, -0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x4 a2 = float3x4(315.37384f, -122.665985f, 447.526123f, -210.4815f, -202.42157f, -453.007935f, 173.72699f, -167.121674f, -106.234528f, 414.312561f, 7.12084961f, 274.073669f);
+            float3x4 b2 = float3x4(-218.209686f, 458.517517f, 119.587219f, 356.240417f, -74.50687f, -336.773926f, -216.126312f, 322.385681f, 220.2555f, -67.2345f, 2.229187f, -166.210968f);
+            float3x4 r2 = float3x4(-1.44527888f, -0.267527372f, 3.742257f, -0.5908412f, 2.71681762f, 1.34513962f, -0.803821564f, -0.5183905f, -0.482324064f, -6.16220236f, 3.19437075f, -1.64895058f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x4 a3 = float3x4(-39.0026855f, 39.065918f, -147.364166f, 434.3849f, 315.0672f, -106.636017f, -507.925262f, -17.1764526f, -385.865356f, 226.002136f, 345.168457f, 201.544189f);
+            float3x4 b3 = float3x4(-247.732574f, 84.16095f, 477.148621f, 209.7508f, -386.7222f, -65.27734f, 410.454834f, 367.6507f, -456.572021f, 382.427979f, -163.860687f, -213.721375f);
+            float3x4 r3 = float3x4(0.157438666f, 0.464181036f, -0.3088433f, 2.07095718f, -0.814712f, 1.6335839f, -1.23746932f, -0.0467194878f, 0.8451358f, 0.5909665f, -2.106475f, -0.9430231f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_div_wide_scalar()
+        {
+            float3x4 a0 = float3x4(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f, 131.526611f, -261.8864f, -348.9238f, -275.5387f, 210.557922f, 287.6424f);
+            float b0 = (-60.0243835f);
+            float3x4 r0 = float3x4(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f, -2.19121981f, 4.36300039f, 5.813034f, 4.590446f, -3.507873f, -4.79209232f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float3x4 a1 = float3x4(504.372253f, -26.6315918f, -253.236664f, 272.895142f, 178.096191f, -460.87558f, -502.646027f, -84.3248f, -174.690338f, 83.7963257f, 197.042053f, 317.168274f);
+            float b1 = (491.7871f);
+            float3x4 r1 = float3x4(1.02559066f, -0.0541526824f, -0.5149315f, 0.554905057f, 0.362140834f, -0.9371445f, -1.02208054f, -0.171466067f, -0.355215371f, 0.17039147f, 0.400665343f, 0.64493f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float3x4 a2 = float3x4(403.387146f, 60.6068726f, -413.5605f, 207.341f, 358.562134f, 20.7490845f, -68.57712f, 310.702454f, 417.4049f, 147.866211f, 506.658875f, -435.778564f);
+            float b2 = (81.6464844f);
+            float3x4 r2 = float3x4(4.940655f, 0.742308438f, -5.06525755f, 2.539497f, 4.391642f, 0.254133224f, -0.8399274f, 3.80546021f, 5.112344f, 1.81105423f, 6.20551968f, -5.33738327f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float3x4 a3 = float3x4(210.672913f, -19.1908569f, 416.511719f, 427.0136f, 417.1994f, -150.911835f, 488.985535f, -294.738739f, -357.298035f, 288.771667f, 453.429138f, 70.72443f);
+            float b3 = (-218.781464f);
+            float3x4 r3 = float3x4(-0.962937653f, 0.08771701f, -1.90377975f, -1.95178151f, -1.90692294f, 0.689783454f, -2.235041f, 1.34718335f, 1.63312757f, -1.31990921f, -2.07252073f, -0.323265165f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float3x4 b0 = float3x4(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f, 333.6645f, 38.2910767f, -472.979767f, 192.230164f, -200.296875f, -490.181519f);
+            float3x4 r0 = float3x4(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f, 0.125088736f, 1.0900104f, -0.0882440954f, 0.217123419f, -0.208379045f, -0.08514738f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (-211.10257f);
+            float3x4 b1 = float3x4(-322.852356f, -137.985291f, 84.32971f, 355.063477f, 276.427246f, -382.988037f, -488.647156f, 344.846f, 168.85498f, -44.1955872f, 420.55072f, -175.6152f);
+            float3x4 r1 = float3x4(0.6538672f, 1.52989185f, -2.5033f, -0.5945488f, -0.7636822f, 0.55119884f, 0.432014316f, -0.612164736f, -1.25020039f, 4.776553f, -0.501966953f, 1.20207453f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (-9.220581f);
+            float3x4 b2 = float3x4(-344.194275f, -449.0715f, 117.704895f, -337.0274f, 239.393433f, -389.355164f, 242.716064f, 496.2765f, 91.74579f, -490.492126f, 485.755432f, -317.572266f);
+            float3x4 r2 = float3x4(0.0267888848f, 0.0205325447f, -0.0783364251f, 0.02735855f, -0.038516432f, 0.0236816723f, -0.0379891656f, -0.018579524f, -0.100501411f, 0.0187986325f, -0.018981941f, 0.0290345922f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-451.6248f);
+            float3x4 b3 = float3x4(394.018372f, -262.271423f, -314.246765f, 359.9159f, -101.615356f, 359.517273f, -424.9799f, -192.719574f, -169.749725f, -244.790009f, -187.14386f, -207.713654f);
+            float3x4 r3 = float3x4(-1.14620233f, 1.72197485f, 1.43716609f, -1.2548064f, 4.444454f, -1.25619769f, 1.06269681f, 2.3434298f, 2.66053319f, 1.84494781f, 2.41324925f, 2.17426634f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mod_wide_wide()
+        {
+            float3x4 a0 = float3x4(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -463.368378f, 83.83911f);
+            float3x4 b0 = float3x4(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f, 487.0462f, -469.8291f, -145.203766f, -203.384f, -22.52008f, 224.69f);
+            float3x4 r0 = float3x4(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -12.9667664f, 83.83911f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x4 a1 = float3x4(-64.71405f, 295.066833f, 212.25708f, 349.6283f, 119.875916f, -37.8058167f, 142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f);
+            float3x4 b1 = float3x4(-435.62674f, 12.0955811f, 40.3787842f, 345.784851f, -433.471252f, -355.649963f, 4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f);
+            float3x4 r1 = float3x4(-64.71405f, 4.772888f, 10.3631592f, 3.84344482f, 119.875916f, -37.8058167f, 1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x4 a2 = float3x4(156.985718f, 507.6183f, 270.830444f, 337.7343f, 384.915833f, 432.5182f, 154.292725f, -37.0853271f, 7.76147461f, 238.094727f, 12.8520508f, -100.240662f);
+            float3x4 b2 = float3x4(-131.4183f, -473.9876f, 76.2178345f, 92.2102051f, -368.189575f, -77.46716f, 135.230591f, 274.277283f, 132.180237f, -179.877319f, 51.9685669f, 367.214233f);
+            float3x4 r2 = float3x4(25.5674133f, 33.6306763f, 42.17694f, 61.1037f, 16.7262573f, 45.182373f, 19.0621338f, -37.0853271f, 7.76147461f, 58.2174072f, 12.8520508f, -100.240662f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x4 a3 = float3x4(34.552002f, -251.189758f, -238.372253f, 511.514648f, 288.433533f, 367.109863f, 44.760437f, -437.0456f, -259.2056f, -228.565826f, 83.49725f, 424.367065f);
+            float3x4 b3 = float3x4(-395.2128f, 270.485229f, -73.104126f, 89.3499756f, -288.308533f, -168.324646f, 311.6159f, -468.341949f, 381.983948f, -1.39886475f, -102.288605f, -87.4248657f);
+            float3x4 r3 = float3x4(34.552002f, -251.189758f, -19.0598755f, 64.76477f, 0.125f, 30.4605713f, 44.760437f, -437.0456f, -259.2056f, -0.5508728f, 83.49725f, 74.6676f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mod_wide_scalar()
+        {
+            float3x4 a0 = float3x4(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f, -450.807678f, 186.094788f, -84.47363f, -318.7815f, 433.4547f, -54.60019f);
+            float b0 = (-90.49924f);
+            float3x4 r0 = float3x4(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f, -88.81073f, 5.09631348f, -84.47363f, -47.283783f, 71.45776f, -54.60019f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float3x4 a1 = float3x4(-172.338867f, 222.361877f, 5.79638672f, 254.5108f, -433.0937f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 483.5506f);
+            float b1 = (-429.714661f);
+            float3x4 r1 = float3x4(-172.338867f, 222.361877f, 5.79638672f, 254.5108f, -3.37902832f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 53.8359375f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float3x4 a2 = float3x4(-331.993347f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 405.773621f, -194.761444f, 235.724f, 465.984863f, -304.153168f, -295.520264f, 313.7224f);
+            float b2 = (336f);
+            float3x4 r2 = float3x4(-331.993347f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 69.77362f, -194.761444f, 235.724f, 129.984863f, -304.153168f, -295.520264f, 313.7224f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float3x4 a3 = float3x4(-232.202637f, 244.096619f, 162.524231f, 390.016174f, 90.00452f, 155.933533f, 217.3377f, -306.819275f, 149.09375f, 503.828369f, -194.130127f, 214.863037f);
+            float b3 = (191.619751f);
+            float3x4 r3 = float3x4(-40.5828857f, 52.4768677f, 162.524231f, 6.77667236f, 90.00452f, 155.933533f, 25.7179565f, -115.199524f, 149.09375f, 120.588867f, -2.510376f, 23.2432861f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float3x4 b0 = float3x4(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f, 397.0448f, -393.890656f, -372.067078f, 201.012268f, -95.566864f, -258.951477f);
+            float3x4 r0 = float3x4(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f, -396.4224f, -2.53173828f, -24.3553162f, -195.410126f, -14.1549377f, -137.470917f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (106.983582f);
+            float3x4 b1 = float3x4(469.323547f, -34.80899f, 184.836548f, 374.79425f, -131.872711f, -120.092865f, 4.506653f, -111.401947f, 391.54248f, -218.668884f, 196.377441f, -511.032623f);
+            float3x4 r1 = float3x4(106.983582f, 2.55661f, 106.983582f, 106.983582f, 106.983582f, 106.983582f, 3.33056641f, 106.983582f, 106.983582f, 106.983582f, 106.983582f, 106.983582f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (499.9535f);
+            float3x4 b2 = float3x4(-433.523071f, -163.866852f, 177.004028f, 110.650146f, 17.68457f, -95.85297f, -432.440979f, 192.692078f, -268.131775f, 271.075134f, 423.7027f, -413.233246f);
+            float3x4 r2 = float3x4(66.43042f, 8.352936f, 145.945435f, 57.3529053f, 4.78552246f, 20.68866f, 67.51251f, 114.569336f, 231.821716f, 228.878357f, 76.25079f, 86.7202454f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (127.956238f);
+            float3x4 b3 = float3x4(-298.204681f, -352.4181f, -175.607727f, -152.899292f, 34.6194458f, -380.802948f, 0.352050781f, 485.900879f, 266.150818f, 483.82074f, 11.777832f, 274.135864f);
+            float3x4 r3 = float3x4(127.956238f, 127.956238f, 127.956238f, 127.956238f, 24.0979f, 127.956238f, 0.1618042f, 127.956238f, 127.956238f, 127.956238f, 10.1779175f, 127.956238f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_plus()
+        {
+            float3x4 a0 = float3x4(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f);
+            float3x4 r0 = float3x4(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float3x4 a1 = float3x4(377.230164f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f);
+            float3x4 r1 = float3x4(377.230164f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float3x4 a2 = float3x4(-364.802551f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f);
+            float3x4 r2 = float3x4(-364.802551f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float3x4 a3 = float3x4(-29.0835266f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f, 87.64923f);
+            float3x4 r3 = float3x4(-29.0835266f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f, 87.64923f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_neg()
+        {
+            float3x4 a0 = float3x4(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f, -495.837952f, -270.859467f, 19.68689f, 268.2367f, -180.600525f, 223.381287f);
+            float3x4 r0 = float3x4(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f, 495.837952f, 270.859467f, -19.68689f, -268.2367f, 180.600525f, -223.381287f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float3x4 a1 = float3x4(-410.392059f, -349.149475f, -110.9393f, -238.2196f, 292.543518f, 469.2926f, 48.29071f, 88.7237549f, 66.1485f, 55.7080078f, 464.541382f, 499.2428f);
+            float3x4 r1 = float3x4(410.392059f, 349.149475f, 110.9393f, 238.2196f, -292.543518f, -469.2926f, -48.29071f, -88.7237549f, -66.1485f, -55.7080078f, -464.541382f, -499.2428f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float3x4 a2 = float3x4(175.015015f, -306.1656f, 149.660034f, 320.391724f, -359.8338f, 22.0384521f, -159.55426f, 419.822449f, 303.323425f, 363.716736f, 280.887878f, -270.6513f);
+            float3x4 r2 = float3x4(-175.015015f, 306.1656f, -149.660034f, -320.391724f, 359.8338f, -22.0384521f, 159.55426f, -419.822449f, -303.323425f, -363.716736f, -280.887878f, 270.6513f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float3x4 a3 = float3x4(-201.615753f, 95.48926f, 191.070251f, 371.973572f, 296.512573f, -164.169922f, -347.4581f, -237.404968f, -228.701965f, 61.0822754f, 128.331543f, 331.2558f);
+            float3x4 r3 = float3x4(201.615753f, -95.48926f, -191.070251f, -371.973572f, -296.512573f, 164.169922f, 347.4581f, 237.404968f, 228.701965f, -61.0822754f, -128.331543f, -331.2558f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_prefix_inc()
+        {
+            float3x4 a0 = float3x4(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f, -323.614868f, -456.8903f, -76.50766f, -305.584778f, 64.0965f, 148.679321f);
+            float3x4 r0 = float3x4(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f, -322.614868f, -455.8903f, -75.50766f, -304.584778f, 65.0965f, 149.679321f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float3x4 a1 = float3x4(363.2849f, -326.8778f, -179.894653f, 339.8766f, -38.41043f, -153.373688f, 261.625549f, 155.030823f, -396.650238f, 301.3058f, -221.355408f, -429.698151f);
+            float3x4 r1 = float3x4(364.2849f, -325.8778f, -178.894653f, 340.8766f, -37.41043f, -152.373688f, 262.625549f, 156.030823f, -395.650238f, 302.3058f, -220.355408f, -428.698151f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float3x4 a2 = float3x4(-271.2893f, -377.5592f, 223.232422f, -71.076355f, -388.2279f, 131.283142f, 22.3049316f, -480.760468f, 200.951782f, 117.9541f, 139.525818f, 335.6897f);
+            float3x4 r2 = float3x4(-270.2893f, -376.5592f, 224.232422f, -70.076355f, -387.2279f, 132.283142f, 23.3049316f, -479.760468f, 201.951782f, 118.9541f, 140.525818f, 336.6897f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float3x4 a3 = float3x4(162.6615f, -254.7315f, -89.25604f, 314.36554f, 244.728149f, 34.01062f, -90.44528f, -472.63623f, -34.5667725f, -71.27185f, -396.4901f, -314.987457f);
+            float3x4 r3 = float3x4(163.6615f, -253.7315f, -88.25604f, 315.36554f, 245.728149f, 35.01062f, -89.44528f, -471.63623f, -33.5667725f, -70.27185f, -395.4901f, -313.987457f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_postfix_inc()
+        {
+            float3x4 a0 = float3x4(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f);
+            float3x4 r0 = float3x4(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float3x4 a1 = float3x4(159.861023f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f);
+            float3x4 r1 = float3x4(159.861023f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float3x4 a2 = float3x4(-341.498535f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f);
+            float3x4 r2 = float3x4(-341.498535f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float3x4 a3 = float3x4(64.57703f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f, 439.3f);
+            float3x4 r3 = float3x4(64.57703f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f, 439.3f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_prefix_dec()
+        {
+            float3x4 a0 = float3x4(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f, 337.968933f, 246.088989f, 171.964539f, -227.44281f, 298.2848f, 326.5078f);
+            float3x4 r0 = float3x4(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f, 336.968933f, 245.088989f, 170.964539f, -228.44281f, 297.2848f, 325.5078f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float3x4 a1 = float3x4(400.7209f, -326.452972f, -24.5845032f, 112.796875f, -341.9763f, -503.27417f, -79.6352539f, -131.00415f, 147.893677f, -15.7086487f, 188.758423f, 307.791931f);
+            float3x4 r1 = float3x4(399.7209f, -327.452972f, -25.5845032f, 111.796875f, -342.9763f, -504.27417f, -80.6352539f, -132.00415f, 146.893677f, -16.7086487f, 187.758423f, 306.791931f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float3x4 a2 = float3x4(-406.667725f, -188.69223f, -505.2157f, -372.241943f, -4.031769f, 83.76776f, -30.6314087f, -436.906555f, -51.668396f, 345.021545f, 4.73535156f, -68.65332f);
+            float3x4 r2 = float3x4(-407.667725f, -189.69223f, -506.2157f, -373.241943f, -5.031769f, 82.76776f, -31.6314087f, -437.906555f, -52.668396f, 344.021545f, 3.73535156f, -69.65332f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float3x4 a3 = float3x4(481.4961f, -357.673279f, 153.329651f, -233.624329f, -35.23831f, 340.619629f, 259.928833f, 335.354919f, 85.36487f, -1.39398193f, -407.4104f, -145.793427f);
+            float3x4 r3 = float3x4(480.4961f, -358.673279f, 152.329651f, -234.624329f, -36.23831f, 339.619629f, 258.928833f, 334.354919f, 84.36487f, -2.393982f, -408.4104f, -146.793427f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float3x4_operator_postfix_dec()
+        {
+            float3x4 a0 = float3x4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f);
+            float3x4 r0 = float3x4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float3x4 a1 = float3x4(-261.0089f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f);
+            float3x4 r1 = float3x4(-261.0089f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float3x4 a2 = float3x4(379.156128f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f);
+            float3x4 r2 = float3x4(379.156128f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float3x4 a3 = float3x4(449.637756f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f, -240.610687f);
+            float3x4 r3 = float3x4(449.637756f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f, -240.610687f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..fd7a21fed6e86584b1259344b03205e3efe57f6d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat3x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f8e09d2585c55f8498cd3e3221744e39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6637e0a076c4d467a67e852bdb00545415646df5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs
@@ -0,0 +1,1069 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat4
+    {
+        [TestCompiler]
+        public static void float4_zero()
+        {
+            TestUtils.AreEqual(float4.zero.x, 0.0f);
+            TestUtils.AreEqual(float4.zero.y, 0.0f);
+            TestUtils.AreEqual(float4.zero.z, 0.0f);
+            TestUtils.AreEqual(float4.zero.w, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4_constructor()
+        {
+            float4 a = new float4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void float4_scalar_constructor()
+        {
+            float4 a = new float4(17.0f);
+            TestUtils.AreEqual(a.x, 17.0f);
+            TestUtils.AreEqual(a.y, 17.0f);
+            TestUtils.AreEqual(a.z, 17.0f);
+            TestUtils.AreEqual(a.w, 17.0f);
+        }
+
+        [TestCompiler]
+        public static void float4_static_constructor()
+        {
+            float4 a = float4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void float4_static_scalar_constructor()
+        {
+            float4 a = float4(17.0f);
+            TestUtils.AreEqual(a.x, 17.0f);
+            TestUtils.AreEqual(a.y, 17.0f);
+            TestUtils.AreEqual(a.z, 17.0f);
+            TestUtils.AreEqual(a.w, 17.0f);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_equal_wide_wide()
+        {
+            float4 a0 = float4(-135.18924f, -49.0941162f, 169.129822f, 240.8053f);
+            float4 b0 = float4(-220.014648f, 66.98004f, 499.2016f, -371.1131f);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4 a1 = float4(314.7392f, 442.393f, 177.924438f, 335.5334f);
+            float4 b1 = float4(208.448669f, 390.8037f, -72.44382f, 362.97644f);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4 a2 = float4(168.15448f, 350.729553f, 367.178467f, 46.9414673f);
+            float4 b2 = float4(194.678345f, 471.644836f, -404.044678f, -144.696747f);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4 a3 = float4(188.76416f, -97.2113953f, -293.320984f, -234.822937f);
+            float4 b3 = float4(-494.446655f, -252.970367f, 234.417114f, 398.724f);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_equal_wide_scalar()
+        {
+            float4 a0 = float4(65.6712f, 404.415527f, -269.730164f, 83.6306152f);
+            float b0 = (-155.815765f);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4 a1 = float4(152.9945f, 314.671265f, 386.365173f, 290.04895f);
+            float b1 = (-155.868286f);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4 a2 = float4(-132.6352f, -69.68326f, -191.190765f, 186.845215f);
+            float b2 = (-65.66748f);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4 a3 = float4(-232.895691f, -49.70108f, -300.8819f, 333.396851f);
+            float b3 = (-319.144043f);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float4 b0 = float4(-400.4892f, -71.2868347f, 156.978088f, -225.238739f);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (499.141785f);
+            float4 b1 = float4(-211.979919f, 428.311951f, -489.501343f, -5.691559f);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (-30.8659363f);
+            float4 b2 = float4(-362.9831f, 184.503174f, -160.470612f, 316.668823f);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (390.369263f);
+            float4 b3 = float4(505.1051f, -294.6487f, 443.1991f, 96.5592651f);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_not_equal_wide_wide()
+        {
+            float4 a0 = float4(279.994141f, -43.34201f, -465.724731f, 317.466553f);
+            float4 b0 = float4(-460.9121f, -476.009033f, 468.1364f, -341.012543f);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4 a1 = float4(85.7149658f, 360.8905f, 366.081543f, 154.542847f);
+            float4 b1 = float4(-62.65805f, -458.801666f, -457.730225f, -59.5232544f);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4 a2 = float4(332.4262f, 397.11322f, -431.374969f, 489.0108f);
+            float4 b2 = float4(3.024231f, 155.812744f, -19.8399048f, -6.01693726f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4 a3 = float4(398.4336f, -489.817932f, 171.4049f, -67.82968f);
+            float4 b3 = float4(-406.207916f, -102.420715f, -40.362915f, 452.6754f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_not_equal_wide_scalar()
+        {
+            float4 a0 = float4(-155.4411f, -19.4266052f, 174.633057f, 507.920715f);
+            float b0 = (-393.413544f);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4 a1 = float4(59.177063f, -58.92328f, -398.176849f, 492.20105f);
+            float b1 = (171.151489f);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4 a2 = float4(-165.241516f, -380.243256f, 501.899048f, -134.345459f);
+            float b2 = (270.341f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4 a3 = float4(458.400452f, 161.459961f, 261.514221f, -145.6124f);
+            float b3 = (46.7709961f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float4 b0 = float4(459.553223f, 436.453247f, -488.714172f, 392.767944f);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-266.736633f);
+            float4 b1 = float4(338.557861f, -338.100128f, -152.314545f, -452.820679f);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (209.439331f);
+            float4 b2 = float4(50.10797f, 372.4344f, -488.0213f, 489.740784f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (270.4001f);
+            float4 b3 = float4(-472.846771f, -286.850464f, -384.691864f, 443.423523f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_wide_wide()
+        {
+            float4 a0 = float4(51.7102661f, -313.85556f, 283.047668f, 235.021912f);
+            float4 b0 = float4(-261.835236f, -19.81073f, -149.25882f, 205.99823f);
+            bool4 r0 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4 a1 = float4(44.07837f, -207.255676f, 3.38293457f, -144.301331f);
+            float4 b1 = float4(-306.024384f, 102.121704f, 231.906311f, 179.49884f);
+            bool4 r1 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4 a2 = float4(-69.3696f, -135.667969f, -194.787354f, -33.473877f);
+            float4 b2 = float4(473.2249f, 15.8916626f, 270.049927f, 490.914f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4 a3 = float4(-19.67508f, 423.237976f, -71.6983f, -501.886f);
+            float4 b3 = float4(-185.734131f, 76.4331055f, 97.75232f, 419.300781f);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_wide_scalar()
+        {
+            float4 a0 = float4(-221.869781f, -121.546478f, -97.5239258f, 479.8811f);
+            float b0 = (199.0675f);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4 a1 = float4(67.11902f, 282.9666f, 258.2791f, -111.413147f);
+            float b1 = (137.3288f);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4 a2 = float4(-288.081116f, -361.6429f, -68.0881958f, 12.7880249f);
+            float b2 = (82.6654053f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4 a3 = float4(-66.703064f, 25.7277222f, 101.37085f, -330.442657f);
+            float b3 = (-78.76297f);
+            bool4 r3 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float4 b0 = float4(-377.196533f, -505.147552f, 375.9267f, 110.17395f);
+            bool4 r0 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (-118.097565f);
+            float4 b1 = float4(-40.4508972f, -299.744324f, 31.4371338f, -458.904541f);
+            bool4 r1 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (13.6846924f);
+            float4 b2 = float4(-458.5069f, 248.276489f, 389.231445f, 488.745544f);
+            bool4 r2 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-221.637878f);
+            float4 b3 = float4(-424.2672f, 249.059021f, -22.1361389f, -442.247742f);
+            bool4 r3 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_wide_wide()
+        {
+            float4 a0 = float4(-229.29068f, 505.536621f, -73.80707f, 100.292053f);
+            float4 b0 = float4(-445.845032f, -420.035278f, 299.0244f, -13.8809814f);
+            bool4 r0 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4 a1 = float4(-419.214783f, -159.559753f, -396.770355f, 127.037415f);
+            float4 b1 = float4(151.5617f, -163.50943f, -391.096039f, 479.283752f);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4 a2 = float4(489.1399f, 51.9188843f, 155.384766f, -135.631653f);
+            float4 b2 = float4(-77.6748657f, -46.584198f, -415.377f, 71.46698f);
+            bool4 r2 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4 a3 = float4(-425.978149f, -228.430511f, 383.03833f, 136.533569f);
+            float4 b3 = float4(-206.061035f, 360.8363f, 236.968811f, 14.550354f);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_wide_scalar()
+        {
+            float4 a0 = float4(11.156311f, -411.023224f, 385.885559f, -485.103058f);
+            float b0 = (-302.816956f);
+            bool4 r0 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4 a1 = float4(-491.180023f, 173.575073f, 69.26929f, 501.306824f);
+            float b1 = (405.175354f);
+            bool4 r1 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4 a2 = float4(-367.027771f, -489.090576f, -172.518158f, -18.1496277f);
+            float b2 = (-86.12451f);
+            bool4 r2 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4 a3 = float4(-236.414948f, -27.2391357f, 471.779358f, 240.164551f);
+            float b3 = (-238.8945f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float4 b0 = float4(-226.2044f, -423.465f, 409.405518f, 453.877075f);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (87.47571f);
+            float4 b1 = float4(113.795593f, 176.409241f, -140.440033f, -182.48288f);
+            bool4 r1 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (-158.2933f);
+            float4 b2 = float4(-162.685333f, -193.328674f, 230.181274f, -102.58783f);
+            bool4 r2 = bool4(true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (392.520569f);
+            float4 b3 = float4(-177.478668f, -10.2950134f, -24.04895f, 172.448669f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_equal_wide_wide()
+        {
+            float4 a0 = float4(240.090515f, 462.213135f, 293.08252f, -427.870667f);
+            float4 b0 = float4(-81.20383f, 493.637451f, -411.4721f, 99.16443f);
+            bool4 r0 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4 a1 = float4(-405.5227f, 204.591919f, 294.6701f, -327.564453f);
+            float4 b1 = float4(-295.6677f, -480.462555f, 74.41406f, 260.916138f);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4 a2 = float4(-456.12326f, 282.30127f, 421.881165f, -311.71283f);
+            float4 b2 = float4(306.173279f, 139.564819f, -505.752472f, -489.6268f);
+            bool4 r2 = bool4(true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4 a3 = float4(84.5675049f, 447.244629f, -154.494354f, -424.364746f);
+            float4 b3 = float4(-280.0326f, 303.1599f, 511.1902f, -104.659729f);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_equal_wide_scalar()
+        {
+            float4 a0 = float4(309.192444f, 69.67377f, -101.724182f, -315.9724f);
+            float b0 = (292.924255f);
+            bool4 r0 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4 a1 = float4(-346.011047f, -410.870056f, -483.902649f, 183.821167f);
+            float b1 = (424.15387f);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4 a2 = float4(320.4425f, -386.801758f, -182.938812f, 349.250122f);
+            float b2 = (-257.870056f);
+            bool4 r2 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4 a3 = float4(485.311584f, 259.1515f, 450.130066f, -128.525543f);
+            float b3 = (373.5691f);
+            bool4 r3 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float4 b0 = float4(51.1589966f, 340.443665f, 312.81427f, 354.1925f);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (136.396729f);
+            float4 b1 = float4(-94.76788f, 288.5443f, 304.042847f, -148.618073f);
+            bool4 r1 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-506.3001f);
+            float4 b2 = float4(27.5812378f, 48.47113f, 104.883484f, -488.685852f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (-480.435181f);
+            float4 b3 = float4(421.936646f, 239.721069f, -101.018433f, -283.951477f);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_equal_wide_wide()
+        {
+            float4 a0 = float4(-386.5918f, -157.120789f, 391.015259f, -511.886871f);
+            float4 b0 = float4(153.443f, 49.8924561f, 78.02582f, 138.813721f);
+            bool4 r0 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4 a1 = float4(-5.42202759f, 287.645264f, -122.535187f, 7.48144531f);
+            float4 b1 = float4(-225.51059f, -339.3561f, -373.302063f, 364.9359f);
+            bool4 r1 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4 a2 = float4(152.946411f, 48.9862061f, 57.3381348f, 300.4649f);
+            float4 b2 = float4(-322.7154f, 125.47821f, -25.77658f, 297.518921f);
+            bool4 r2 = bool4(true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4 a3 = float4(349.25708f, 85.7496948f, -230.953308f, 418.711243f);
+            float4 b3 = float4(73.22235f, 462.783752f, 393.191345f, -95.0014343f);
+            bool4 r3 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_equal_wide_scalar()
+        {
+            float4 a0 = float4(495.4574f, -14.3451233f, -463.4748f, 217.517517f);
+            float b0 = (189.205139f);
+            bool4 r0 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4 a1 = float4(-246.865723f, 53.8151245f, -123.332947f, -221.505463f);
+            float b1 = (-377.6587f);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4 a2 = float4(252.994324f, -395.3633f, 164.772583f, -287.007324f);
+            float b2 = (-116.440369f);
+            bool4 r2 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4 a3 = float4(355.837036f, 273.012268f, -418.1424f, 249.3841f);
+            float b3 = (184.195557f);
+            bool4 r3 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float4 b0 = float4(204.802979f, -101.104034f, -122.055023f, -70.45615f);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (-239.62027f);
+            float4 b1 = float4(-185.992737f, -455.612579f, 276.665833f, 79.39917f);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (416.420532f);
+            float4 b2 = float4(379.2735f, -439.5147f, 67.14099f, -74.56064f);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (-367.256348f);
+            float4 b3 = float4(494.950745f, -61.2355347f, -429.170258f, -213.824677f);
+            bool4 r3 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_add_wide_wide()
+        {
+            float4 a0 = float4(465.148376f, 278.9107f, -277.5299f, -65.1972046f);
+            float4 b0 = float4(483.9944f, -204.07666f, -365.673553f, -509.920868f);
+            float4 r0 = float4(949.142761f, 74.8340454f, -643.2035f, -575.118042f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4 a1 = float4(-473.324371f, -4.69555664f, -470.536774f, -109.9501f);
+            float4 b1 = float4(-270.6975f, 486.763977f, 267.49176f, 251.642517f);
+            float4 r1 = float4(-744.021851f, 482.06842f, -203.045013f, 141.692413f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4 a2 = float4(-178.701447f, -420.033783f, 290.711121f, -446.529633f);
+            float4 b2 = float4(244.495117f, -78.67575f, 352.2055f, 82.7791748f);
+            float4 r2 = float4(65.79367f, -498.709534f, 642.9166f, -363.750458f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4 a3 = float4(491.066467f, -261.1173f, -298.4069f, 502.4286f);
+            float4 b3 = float4(462.5473f, -405.492f, -428.498322f, -41.87259f);
+            float4 r3 = float4(953.6138f, -666.6093f, -726.9052f, 460.556f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_add_wide_scalar()
+        {
+            float4 a0 = float4(459.898315f, -447.663361f, -94.43863f, 126.429871f);
+            float b0 = (500.997253f);
+            float4 r0 = float4(960.895569f, 53.3338928f, 406.558624f, 627.4271f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4 a1 = float4(-36.254364f, -2.79125977f, -478.4148f, 443.115234f);
+            float b1 = (-349.6413f);
+            float4 r1 = float4(-385.89566f, -352.432556f, -828.0561f, 93.47394f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4 a2 = float4(268.092224f, -471.256073f, -2.664978f, 78.98584f);
+            float b2 = (41.3210449f);
+            float4 r2 = float4(309.413269f, -429.935028f, 38.6560669f, 120.306885f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4 a3 = float4(202.14801f, 10.3458252f, -151.244446f, 355.2328f);
+            float b3 = (311.725464f);
+            float4 r3 = float4(513.8735f, 322.0713f, 160.481018f, 666.958252f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float4 b0 = float4(-264.088135f, -106.009247f, -355.4473f, -447.3303f);
+            float4 r0 = float4(-589.6009f, -431.522f, -680.9601f, -772.843f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (-158.7002f);
+            float4 b1 = float4(-199.4837f, 180.318115f, 337.579346f, -37.0550232f);
+            float4 r1 = float4(-358.1839f, 21.61792f, 178.87915f, -195.755219f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (230.805f);
+            float4 b2 = float4(-140.174347f, 18.02417f, -138.614349f, 26.9041748f);
+            float4 r2 = float4(90.6306458f, 248.829163f, 92.19064f, 257.709167f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (-374.5376f);
+            float4 b3 = float4(154.46759f, 268.38385f, -190.963013f, 188.617249f);
+            float4 r3 = float4(-220.07f, -106.153748f, -565.5006f, -185.920349f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_sub_wide_wide()
+        {
+            float4 a0 = float4(133.371033f, -131.832123f, -197.293152f, -485.28656f);
+            float4 b0 = float4(123.460266f, 359.56012f, -48.2484741f, 478.979065f);
+            float4 r0 = float4(9.910767f, -491.392242f, -149.044678f, -964.2656f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4 a1 = float4(-337.550323f, 471.6671f, 146.506592f, -130.585052f);
+            float4 b1 = float4(207.158325f, 142.36731f, -125.6055f, -65.29901f);
+            float4 r1 = float4(-544.7086f, 329.2998f, 272.1121f, -65.28604f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4 a2 = float4(110.7771f, -235.5416f, 78.87933f, -347.686157f);
+            float4 b2 = float4(-477.876434f, 164.5f, 428.009583f, 72.62781f);
+            float4 r2 = float4(588.653564f, -400.0416f, -349.130249f, -420.313965f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4 a3 = float4(-470.820557f, -11.45929f, -167.9479f, 330.676758f);
+            float4 b3 = float4(-446.8805f, 432.091431f, -225.554657f, -112.451965f);
+            float4 r3 = float4(-23.9400635f, -443.55072f, 57.60675f, 443.128723f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_sub_wide_scalar()
+        {
+            float4 a0 = float4(48.9367065f, 410.4516f, -364.4417f, 163.980591f);
+            float b0 = (-291.5904f);
+            float4 r0 = float4(340.5271f, 702.042f, -72.85132f, 455.570984f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4 a1 = float4(-460.067322f, 204.358337f, 180.269714f, -377.9257f);
+            float b1 = (110.919434f);
+            float4 r1 = float4(-570.986755f, 93.4389f, 69.35028f, -488.845123f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4 a2 = float4(-470.262054f, 461.507568f, -246.287262f, 21.6052856f);
+            float b2 = (400.5349f);
+            float4 r2 = float4(-870.797f, 60.9726563f, -646.822144f, -378.929626f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4 a3 = float4(246.350708f, -122.718414f, -122.938721f, 360.15094f);
+            float b3 = (-121.427368f);
+            float4 r3 = float4(367.778076f, -1.29104614f, -1.51135254f, 481.5783f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float4 b0 = float4(452.352539f, 256.9898f, -275.159882f, -89.02753f);
+            float4 r0 = float4(-157.766052f, 37.59668f, 569.746338f, 383.614f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (488.2284f);
+            float4 b1 = float4(-333.2173f, -64.233f, -66.04172f, 341.204956f);
+            float4 r1 = float4(821.4457f, 552.4614f, 554.270142f, 147.023438f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (-385.775055f);
+            float4 b2 = float4(75.3947754f, 354.943726f, 169.131409f, 88.21661f);
+            float4 r2 = float4(-461.16983f, -740.71875f, -554.9065f, -473.991669f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (1.73498535f);
+            float4 b3 = float4(122.538025f, -264.945f, -50.83719f, -347.65033f);
+            float4 r3 = float4(-120.80304f, 266.68f, 52.5721741f, 349.3853f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mul_wide_wide()
+        {
+            float4 a0 = float4(-394.780548f, -412.3722f, -25.8745728f, -241.045959f);
+            float4 b0 = float4(-149.763977f, -345.04538f, -284.334045f, 267.979248f);
+            float4 r0 = float4(59123.9063f, 142287.125f, 7357.022f, -64595.3164f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4 a1 = float4(-93.6759949f, 244.159973f, 494.688477f, 53.5379639f);
+            float4 b1 = float4(-326.6485f, -150.689667f, 207.732422f, 366.192871f);
+            float4 r1 = float4(30599.123f, -36792.3867f, 102762.836f, 19605.22f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4 a2 = float4(-239.4964f, 236.675842f, -211.8562f, -216.654816f);
+            float4 b2 = float4(358.880737f, 214.853577f, 253.422791f, -307.7138f);
+            float4 r2 = float4(-85950.64f, 50850.6523f, -53689.19f, 66667.68f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4 a3 = float4(467.9583f, -178.021912f, -386.394257f, -422.4354f);
+            float4 b3 = float4(184.47113f, 426.436462f, -144.281433f, 459.4796f);
+            float4 r3 = float4(86324.8f, -75915.03f, 55749.5156f, -194100.453f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mul_wide_scalar()
+        {
+            float4 a0 = float4(328.203f, -290.10672f, 236.995728f, 120.481384f);
+            float b0 = (192.211182f);
+            float4 r0 = float4(63084.2852f, -55761.7539f, 45553.23f, 23157.87f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4 a1 = float4(357.903137f, -477.3105f, -438.272919f, -46.729187f);
+            float b1 = (134.867249f);
+            float4 r1 = float4(48269.41f, -64373.55f, -59108.6641f, -6302.237f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4 a2 = float4(-238.405f, -48.83484f, 355.30835f, 119.356628f);
+            float b2 = (422.08252f);
+            float4 r2 = float4(-100626.586f, -20612.332f, 149969.438f, 50378.3477f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4 a3 = float4(-196.995819f, -325.552155f, 53.9373169f, -87.45099f);
+            float b3 = (98.23602f);
+            float4 r3 = float4(-19352.0859f, -31980.95f, 5298.5874f, -8590.837f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float4 b0 = float4(329.360962f, -198.683441f, 184.0794f, 256.016174f);
+            float4 r0 = float4(-152999.6f, 92295.35f, -85511.27f, -118928.4f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (266.226318f);
+            float4 b1 = float4(-97.8947449f, 159.748108f, -351.8222f, 491.801575f);
+            float4 r1 = float4(-26062.1582f, 42529.1523f, -93664.33f, 130930.523f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (49.90204f);
+            float4 b2 = float4(424.4626f, 160.1181f, -395.9921f, 125.20166f);
+            float4 r2 = float4(21181.5488f, 7990.21973f, -19760.8125f, 6247.818f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (-265.0158f);
+            float4 b3 = float4(314.656128f, -292.712036f, -37.72989f, 165.362244f);
+            float4 r3 = float4(-83388.85f, 77573.32f, 9999.017f, -43823.61f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_div_wide_wide()
+        {
+            float4 a0 = float4(246.265747f, -269.85614f, -451.619537f, -7.388489f);
+            float4 b0 = float4(172.119812f, -77.14111f, -325.8354f, -450.608673f);
+            float4 r0 = float4(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4 a1 = float4(-308.205566f, -373.3948f, 360.41864f, 25.8097534f);
+            float4 b1 = float4(-261.262146f, -122.449493f, -93.2107849f, -442.005219f);
+            float4 r1 = float4(1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4 a2 = float4(-274.050476f, 127.538574f, -447.671753f, -137.458588f);
+            float4 b2 = float4(484.362732f, -390.7818f, 402.02533f, 316.6507f);
+            float4 r2 = float4(-0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4 a3 = float4(-136.133179f, 12.4376221f, 228.513f, 356.972351f);
+            float4 b3 = float4(397.154419f, -303.2622f, -118.591248f, -81.6503f);
+            float4 r3 = float4(-0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_div_wide_scalar()
+        {
+            float4 a0 = float4(-244.517456f, 69.1123047f, -333.023132f, 257.396851f);
+            float b0 = (-60.0243835f);
+            float4 r0 = float4(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4 a1 = float4(403.2456f, 131.526611f, -261.8864f, -348.9238f);
+            float b1 = (154.34436f);
+            float4 r1 = float4(2.61263585f, 0.8521634f, -1.696767f, -2.26068377f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4 a2 = float4(-275.5387f, 287.6424f, 504.372253f, 491.7871f);
+            float b2 = (210.557922f);
+            float4 r2 = float4(-1.30861235f, 1.36609626f, 2.39540863f, 2.335638f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4 a3 = float4(-26.6315918f, 272.895142f, 178.096191f, -460.87558f);
+            float b3 = (-253.236664f);
+            float4 r3 = float4(0.105164833f, -1.07762885f, -0.7032797f, 1.81994021f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float4 b0 = float4(-422.676147f, 248.129639f, 449.391357f, 245.858154f);
+            float4 r0 = float4(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (-326.6206f);
+            float4 b1 = float4(163.715088f, 333.6645f, 38.2910767f, -472.979767f);
+            float4 r1 = float4(-1.995055f, -0.978889346f, -8.529941f, 0.6905594f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (192.230164f);
+            float4 b2 = float4(-200.296875f, -490.181519f, -211.10257f, -322.852356f);
+            float4 r2 = float4(-0.9597262f, -0.3921612f, -0.9106008f, -0.595412f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-137.985291f);
+            float4 b3 = float4(84.32971f, 355.063477f, 276.427246f, -382.988037f);
+            float4 r3 = float4(-1.63625944f, -0.388621479f, -0.499174f, 0.360286176f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mod_wide_wide()
+        {
+            float4 a0 = float4(-442.309875f, 368.5005f, -1.09390259f, -364.673828f);
+            float4 b0 = float4(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f);
+            float4 r0 = float4(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4 a1 = float4(-197.343933f, -34.0349121f, -101.348572f, 208.318542f);
+            float4 b1 = float4(-154.61026f, -154.029358f, 487.0462f, -469.8291f);
+            float4 r1 = float4(-42.7336731f, -34.0349121f, -101.348572f, 208.318542f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4 a2 = float4(-140.770325f, 183.44696f, -463.368378f, 83.83911f);
+            float4 b2 = float4(-145.203766f, -203.384f, -22.52008f, 224.69f);
+            float4 r2 = float4(-140.770325f, 183.44696f, -12.9667664f, 83.83911f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4 a3 = float4(-64.71405f, 295.066833f, 212.25708f, 349.6283f);
+            float4 b3 = float4(-435.62674f, 12.0955811f, 40.3787842f, 345.784851f);
+            float4 r3 = float4(-64.71405f, 4.772888f, 10.3631592f, 3.84344482f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mod_wide_scalar()
+        {
+            float4 a0 = float4(-433.417f, -5.51412964f, 393.3944f, 299.41156f);
+            float b0 = (-90.49924f);
+            float4 r0 = float4(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4 a1 = float4(-120.80603f, -450.807678f, 186.094788f, -84.47363f);
+            float b1 = (-502.939026f);
+            float4 r1 = float4(-120.80603f, -450.807678f, 186.094788f, -84.47363f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4 a2 = float4(-318.7815f, -54.60019f, -172.338867f, -429.714661f);
+            float b2 = (433.4547f);
+            float4 r2 = float4(-318.7815f, -54.60019f, -172.338867f, -429.714661f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4 a3 = float4(222.361877f, 254.5108f, -433.0937f, -203.082611f);
+            float b3 = (5.79638672f);
+            float4 r3 = float4(2.09918213f, 5.26617432f, -4.161072f, -0.209075928f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float4 b0 = float4(-159.140259f, 230.17334f, 14.7793579f, -303.1565f);
+            float4 r0 = float4(-78.14188f, -166.249054f, -12.1590881f, -93.2659f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (399.635f);
+            float4 b1 = float4(206.6947f, 397.0448f, -393.890656f, -372.067078f);
+            float4 r1 = float4(192.9403f, 2.59021f, 5.74435425f, 27.5679321f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (201.012268f);
+            float4 b2 = float4(-95.566864f, -258.951477f, 106.983582f, 469.323547f);
+            float4 r2 = float4(9.87854f, 201.012268f, 94.02869f, 201.012268f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (-34.80899f);
+            float4 b3 = float4(184.836548f, 374.79425f, -131.872711f, -120.092865f);
+            float4 r3 = float4(-34.80899f, -34.80899f, -34.80899f, -34.80899f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_plus()
+        {
+            float4 a0 = float4(271.670837f, -79.08023f, -330.985046f, 31.824707f);
+            float4 r0 = float4(271.670837f, -79.08023f, -330.985046f, 31.824707f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float4 a1 = float4(315.449524f, 190.324646f, -350.3086f, -320.518463f);
+            float4 r1 = float4(315.449524f, 190.324646f, -350.3086f, -320.518463f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float4 a2 = float4(102.054382f, -428.7762f, 377.230164f, 234.773926f);
+            float4 r2 = float4(102.054382f, -428.7762f, 377.230164f, 234.773926f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float4 a3 = float4(34.28363f, 465.355957f, 309.59314f, -316.937134f);
+            float4 r3 = float4(34.28363f, 465.355957f, 309.59314f, -316.937134f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_neg()
+        {
+            float4 a0 = float4(420.227173f, -196.2575f, -335.426819f, 509.04364f);
+            float4 r0 = float4(-420.227173f, 196.2575f, 335.426819f, -509.04364f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float4 a1 = float4(-33.0144043f, -495.837952f, -270.859467f, 19.68689f);
+            float4 r1 = float4(33.0144043f, 495.837952f, 270.859467f, -19.68689f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float4 a2 = float4(268.2367f, 223.381287f, -410.392059f, -395.681549f);
+            float4 r2 = float4(-268.2367f, -223.381287f, 410.392059f, 395.681549f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float4 a3 = float4(-349.149475f, -238.2196f, 292.543518f, 469.2926f);
+            float4 r3 = float4(349.149475f, 238.2196f, -292.543518f, -469.2926f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_prefix_inc()
+        {
+            float4 a0 = float4(-99.79556f, 458.741821f, 96.1790161f, -48.55246f);
+            float4 r0 = float4(-98.79556f, 459.741821f, 97.1790161f, -47.55246f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float4 a1 = float4(-315.728973f, -323.614868f, -456.8903f, -76.50766f);
+            float4 r1 = float4(-314.728973f, -322.614868f, -455.8903f, -75.50766f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float4 a2 = float4(-305.584778f, 148.679321f, 363.2849f, -115.559235f);
+            float4 r2 = float4(-304.584778f, 149.679321f, 364.2849f, -114.559235f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float4 a3 = float4(-326.8778f, 339.8766f, -38.41043f, -153.373688f);
+            float4 r3 = float4(-325.8778f, 340.8766f, -37.41043f, -152.373688f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_postfix_inc()
+        {
+            float4 a0 = float4(322.943542f, 472.0525f, 203.48761f, -49.8545837f);
+            float4 r0 = float4(322.943542f, 472.0525f, 203.48761f, -49.8545837f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float4 a1 = float4(-31.4205322f, 271.454651f, 55.7368774f, 153.7503f);
+            float4 r1 = float4(-31.4205322f, 271.454651f, 55.7368774f, 153.7503f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float4 a2 = float4(-174.173f, 215.110229f, 159.861023f, -333.050446f);
+            float4 r2 = float4(-174.173f, 215.110229f, 159.861023f, -333.050446f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float4 a3 = float4(241.4649f, -170.104645f, -270.652466f, -162.86026f);
+            float4 r3 = float4(241.4649f, -170.104645f, -270.652466f, -162.86026f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_prefix_dec()
+        {
+            float4 a0 = float4(-416.201233f, -96.63788f, -50.14566f, -207.316437f);
+            float4 r0 = float4(-417.201233f, -97.63788f, -51.14566f, -208.316437f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float4 a1 = float4(439.479065f, 337.968933f, 246.088989f, 171.964539f);
+            float4 r1 = float4(438.479065f, 336.968933f, 245.088989f, 170.964539f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float4 a2 = float4(-227.44281f, 326.5078f, 400.7209f, -478.031372f);
+            float4 r2 = float4(-228.44281f, 325.5078f, 399.7209f, -479.031372f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float4 a3 = float4(-326.452972f, 112.796875f, -341.9763f, -503.27417f);
+            float4 r3 = float4(-327.452972f, 111.796875f, -342.9763f, -504.27417f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_operator_postfix_dec()
+        {
+            float4 a0 = float4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f);
+            float4 r0 = float4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float4 a1 = float4(409.557556f, -281.1117f, -262.0626f, -182.405731f);
+            float4 r1 = float4(409.557556f, -281.1117f, -262.0626f, -182.405731f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float4 a2 = float4(450.1281f, -332.154968f, -261.0089f, 205.461121f);
+            float4 r2 = float4(450.1281f, -332.154968f, -261.0089f, 205.461121f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float4 a3 = float4(-230.227783f, 378.641235f, 487.344849f, -192.177856f);
+            float4 r3 = float4(-230.227783f, 378.641235f, 487.344849f, -192.177856f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void float4_shuffle_result_1()
+        {
+            float4 a = float4(0, 1, 2, 3);
+            float4 b = float4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW), (3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ), (6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW), (7));
+        }
+
+        [TestCompiler]
+        public static void float4_shuffle_result_2()
+        {
+            float4 a = float4(0, 1, 2, 3);
+            float4 b = float4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), float2(5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX), float2(6, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), float2(1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftW), float2(7, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftZ), float2(7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), float2(2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW), float2(5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), float2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightW), float2(6, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ), float2(5, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), float2(6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), float2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), float2(5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightY), float2(7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), float2(4, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW), float2(1, 3));
+        }
+
+        [TestCompiler]
+        public static void float4_shuffle_result_3()
+        {
+            float4 a = float4(0, 1, 2, 3);
+            float4 b = float4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightY), float3(2, 7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.LeftW), float3(6, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightX), float3(2, 7, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), float3(5, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), float3(7, 6, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.LeftY), float3(3, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightX), float3(3, 5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightW), float3(3, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.RightZ), float3(6, 5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), float3(5, 4, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightW, ShuffleComponent.LeftX), float3(7, 7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightY), float3(6, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightW), float3(6, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightY), float3(3, 5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), float3(6, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW), float3(5, 1, 7));
+        }
+
+        [TestCompiler]
+        public static void float4_shuffle_result_4()
+        {
+            float4 a = float4(0, 1, 2, 3);
+            float4 b = float4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ), float4(1, 3, 4, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW, ShuffleComponent.RightZ, ShuffleComponent.RightZ), float4(5, 3, 6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.RightW, ShuffleComponent.LeftZ), float4(6, 6, 7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ), float4(4, 5, 2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), float4(6, 1, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightW), float4(4, 5, 5, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightW, ShuffleComponent.LeftX, ShuffleComponent.RightW), float4(1, 7, 0, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftX), float4(5, 0, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightW, ShuffleComponent.LeftW, ShuffleComponent.LeftY), float4(4, 7, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), float4(5, 4, 1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), float4(0, 2, 6, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightW, ShuffleComponent.RightW), float4(2, 5, 7, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ, ShuffleComponent.RightX), float4(3, 4, 2, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), float4(4, 0, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), float4(6, 4, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY), float4(3, 7, 1, 5));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..3784a8b256bb0da44bc0fe3f5b7d64e965189727
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f415d23fdfcb53742837bd44ef1b7825
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..0dcb4d117ffee2e6c4f914f253f3f7887caf7daa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs
@@ -0,0 +1,945 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat4x2
+    {
+        [TestCompiler]
+        public static void float4x2_zero()
+        {
+            TestUtils.AreEqual(float4x2.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c0.w, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c1.z, 0.0f);
+            TestUtils.AreEqual(float4x2.zero.c1.w, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_equal_wide_wide()
+        {
+            float4x2 a0 = float4x2(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f, 177.924438f, 335.5334f);
+            float4x2 b0 = float4x2(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f, -72.44382f, 362.97644f);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x2 a1 = float4x2(168.15448f, 350.729553f, 367.178467f, 46.9414673f, 188.76416f, -97.2113953f, -293.320984f, -234.822937f);
+            float4x2 b1 = float4x2(194.678345f, 471.644836f, -404.044678f, -144.696747f, -494.446655f, -252.970367f, 234.417114f, 398.724f);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x2 a2 = float4x2(417.0337f, 26.3864136f, 269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f);
+            float4x2 b2 = float4x2(260.4287f, 370.144226f, 89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x2 a3 = float4x2(-22.98944f, 487.260864f, -419.731964f, 337.2033f, 245.043884f, 390.215881f, 84.4129639f, 434.2079f);
+            float4x2 b3 = float4x2(-174.081818f, 395.101135f, 350.3393f, -243.144592f, -416.397369f, 151.576477f, -18.2243347f, -431.677917f);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_equal_wide_scalar()
+        {
+            float4x2 a0 = float4x2(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f, 314.671265f, 386.365173f);
+            float b0 = (-155.815765f);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x2 a1 = float4x2(290.04895f, -65.66748f, -69.68326f, -191.190765f, 186.845215f, -232.895691f, -319.144043f, -49.70108f);
+            float b1 = (-132.6352f);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x2 a2 = float4x2(-300.8819f, 386.3775f, -296.7019f, -309.1172f, 141.542358f, -227.323334f, 83.87286f, -410.91687f);
+            float b2 = (333.396851f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x2 a3 = float4x2(110.501282f, 36.57434f, -427.541443f, -268.170837f, 175.8117f, -193.47995f, 291.051941f, 423.97168f);
+            float b3 = (-390.103577f);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float4x2 b0 = float4x2(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f, 428.311951f, -489.501343f);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (-5.691559f);
+            float4x2 b1 = float4x2(-30.8659363f, -362.9831f, 184.503174f, -160.470612f, 316.668823f, 390.369263f, 505.1051f, -294.6487f);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (443.1991f);
+            float4x2 b2 = float4x2(96.5592651f, -257.012939f, -245.054962f, 326.464844f, -23.9599f, -168.694885f, 386.2486f, -227.090637f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (-336.612427f);
+            float4x2 b3 = float4x2(365.108154f, -405.390839f, -473.995483f, 298.435364f, -149.86322f, 450.0664f, 153.47644f, 56.28778f);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_not_equal_wide_wide()
+        {
+            float4x2 a0 = float4x2(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f, 366.081543f, 154.542847f);
+            float4x2 b0 = float4x2(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f, -457.730225f, -59.5232544f);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x2 a1 = float4x2(332.4262f, 397.11322f, -431.374969f, 489.0108f, 398.4336f, -489.817932f, 171.4049f, -67.82968f);
+            float4x2 b1 = float4x2(3.024231f, 155.812744f, -19.8399048f, -6.01693726f, -406.207916f, -102.420715f, -40.362915f, 452.6754f);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x2 a2 = float4x2(-192.278717f, 227.84082f, 62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f);
+            float4x2 b2 = float4x2(93.25757f, -258.378052f, -184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x2 a3 = float4x2(-72.20682f, 444.749268f, 238.81781f, 365.1801f, -437.9229f, -362.442627f, 445.954346f, -0.417480469f);
+            float4x2 b3 = float4x2(415.071716f, -467.726135f, -433.784668f, -212.165924f, 474.674927f, 452.483215f, -92.11273f, -385.9221f);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_not_equal_wide_scalar()
+        {
+            float4x2 a0 = float4x2(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f, -58.92328f, -398.176849f);
+            float b0 = (-393.413544f);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x2 a1 = float4x2(492.20105f, 270.341f, -380.243256f, 501.899048f, -134.345459f, 458.400452f, 46.7709961f, 161.459961f);
+            float b1 = (-165.241516f);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x2 a2 = float4x2(261.514221f, -0.449920654f, 350.461426f, 202.221008f, 242.664f, 382.677063f, -468.967957f, -497.459473f);
+            float b2 = (-145.6124f);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x2 a3 = float4x2(-80.93225f, -506.490326f, 449.348145f, 210.771f, 249.181824f, -338.468536f, 229.670654f, -76.5433044f);
+            float b3 = (-328.587769f);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float4x2 b0 = float4x2(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f, -338.100128f, -152.314545f);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-452.820679f);
+            float4x2 b1 = float4x2(209.439331f, 50.10797f, 372.4344f, -488.0213f, 489.740784f, 270.4001f, -472.846771f, -286.850464f);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (-384.691864f);
+            float4x2 b2 = float4x2(443.423523f, 358.7472f, -15.4140625f, -342.179169f, 468.967529f, -130.568085f, 401.785828f, -268.352264f);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (-239.231018f);
+            float4x2 b3 = float4x2(411.386536f, 139.769348f, 334.522034f, -223.629242f, -12.4884644f, 113.468872f, -189.652252f, -212.846558f);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_wide_wide()
+        {
+            float4x2 a0 = float4x2(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f, 3.38293457f, -144.301331f);
+            float4x2 b0 = float4x2(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f, 231.906311f, 179.49884f);
+            bool4x2 r0 = bool4x2(false, true, false, false, false, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x2 a1 = float4x2(-69.3696f, -135.667969f, -194.787354f, -33.473877f, -19.67508f, 423.237976f, -71.6983f, -501.886f);
+            float4x2 b1 = float4x2(473.2249f, 15.8916626f, 270.049927f, 490.914f, -185.734131f, 76.4331055f, 97.75232f, 419.300781f);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x2 a2 = float4x2(7.64386f, 302.262878f, -140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f);
+            float4x2 b2 = float4x2(73.953186f, 481.032349f, 7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f);
+            bool4x2 r2 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x2 a3 = float4x2(269.1078f, 462.98822f, 223.884155f, -287.18924f, 283.6386f, 511.864319f, -60.4967957f, -234.303467f);
+            float4x2 b3 = float4x2(-382.315857f, 251.535156f, 143.17395f, 293.660339f, -292.769562f, -43.2182f, -353.4112f, 458.32605f);
+            bool4x2 r3 = bool4x2(false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_wide_scalar()
+        {
+            float4x2 a0 = float4x2(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f, 282.9666f, 258.2791f);
+            float b0 = (199.0675f);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x2 a1 = float4x2(-111.413147f, 82.6654053f, -361.6429f, -68.0881958f, 12.7880249f, -66.703064f, -78.76297f, 25.7277222f);
+            float b1 = (-288.081116f);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x2 a2 = float4x2(101.37085f, -48.9205322f, 359.604431f, -8.150085f, 241.2768f, -183.437775f, 423.027161f, -334.622742f);
+            float b2 = (-330.442657f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x2 a3 = float4x2(-98.31558f, 297.925232f, -492.108154f, -395.807251f, 95.78882f, -220.62146f, -455.37558f, 360.291565f);
+            float b3 = (300.410156f);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float4x2 b0 = float4x2(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f, -299.744324f, 31.4371338f);
+            bool4x2 r0 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (-458.904541f);
+            float4x2 b1 = float4x2(13.6846924f, -458.5069f, 248.276489f, 389.231445f, 488.745544f, -221.637878f, -424.2672f, 249.059021f);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (-22.1361389f);
+            float4x2 b2 = float4x2(-442.247742f, -340.857544f, -95.1117249f, 15.4094238f, 87.29248f, 495.067627f, 316.0185f, -125.568115f);
+            bool4x2 r2 = bool4x2(false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (122.164795f);
+            float4x2 b3 = float4x2(96.75537f, -228.906342f, -143.9527f, -230.238281f, -327.6126f, 103.39801f, 434.488831f, -157.4502f);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_wide_wide()
+        {
+            float4x2 a0 = float4x2(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f, -396.770355f, 127.037415f);
+            float4x2 b0 = float4x2(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f, -391.096039f, 479.283752f);
+            bool4x2 r0 = bool4x2(true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x2 a1 = float4x2(489.1399f, 51.9188843f, 155.384766f, -135.631653f, -425.978149f, -228.430511f, 383.03833f, 136.533569f);
+            float4x2 b1 = float4x2(-77.6748657f, -46.584198f, -415.377f, 71.46698f, -206.061035f, 360.8363f, 236.968811f, 14.550354f);
+            bool4x2 r1 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x2 a2 = float4x2(8.602417f, -251.324371f, -345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f);
+            float4x2 b2 = float4x2(364.735168f, -159.06131f, 226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x2 a3 = float4x2(105.535217f, -170.9253f, 26.9802246f, -188.928314f, 201.786621f, -506.057159f, 15.454895f, 115.080688f);
+            float4x2 b3 = float4x2(-352.1598f, 9.822632f, 186.721619f, -325.913635f, -77.93036f, -379.746033f, 251.45575f, -144.183563f);
+            bool4x2 r3 = bool4x2(true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_wide_scalar()
+        {
+            float4x2 a0 = float4x2(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f, 173.575073f, 69.26929f);
+            float b0 = (-302.816956f);
+            bool4x2 r0 = bool4x2(true, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x2 a1 = float4x2(501.306824f, -86.12451f, -489.090576f, -172.518158f, -18.1496277f, -236.414948f, -238.8945f, -27.2391357f);
+            float b1 = (-367.027771f);
+            bool4x2 r1 = bool4x2(true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x2 a2 = float4x2(471.779358f, -481.4781f, 185.59436f, 33.29474f, -510.228149f, -183.2862f, -386.127655f, -13.6382141f);
+            float b2 = (240.164551f);
+            bool4x2 r2 = bool4x2(true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x2 a3 = float4x2(-7.34790039f, 52.24951f, 16.3232422f, -410.5101f, -262.2675f, -458.255981f, -218.866119f, -34.6923523f);
+            float b3 = (-261.865967f);
+            bool4x2 r3 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float4x2 b0 = float4x2(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f, 176.409241f, -140.440033f);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (-182.48288f);
+            float4x2 b1 = float4x2(-158.2933f, -162.685333f, -193.328674f, 230.181274f, -102.58783f, 392.520569f, -177.478668f, -10.2950134f);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (-24.04895f);
+            float4x2 b2 = float4x2(172.448669f, 374.048035f, -368.99762f, -210.195282f, 149.470215f, -281.343262f, -100.469177f, 304.864441f);
+            bool4x2 r2 = bool4x2(false, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (-361.524841f);
+            float4x2 b3 = float4x2(-372.452362f, -33.9095459f, -69.5952759f, -460.4324f, -309.341675f, 486.131531f, 471.920959f, 479.361572f);
+            bool4x2 r3 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_equal_wide_wide()
+        {
+            float4x2 a0 = float4x2(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f, 294.6701f, -327.564453f);
+            float4x2 b0 = float4x2(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f, 74.41406f, 260.916138f);
+            bool4x2 r0 = bool4x2(false, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x2 a1 = float4x2(-456.12326f, 282.30127f, 421.881165f, -311.71283f, 84.5675049f, 447.244629f, -154.494354f, -424.364746f);
+            float4x2 b1 = float4x2(306.173279f, 139.564819f, -505.752472f, -489.6268f, -280.0326f, 303.1599f, 511.1902f, -104.659729f);
+            bool4x2 r1 = bool4x2(true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x2 a2 = float4x2(36.68451f, 267.0703f, 307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f);
+            float4x2 b2 = float4x2(95.14661f, -125.636353f, 376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f);
+            bool4x2 r2 = bool4x2(true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x2 a3 = float4x2(-77.04346f, 438.1848f, 260.282349f, 386.034058f, -281.491f, -102.930054f, -346.716736f, -258.3412f);
+            float4x2 b3 = float4x2(-216.002319f, 66.73425f, 99.21863f, 233.843018f, 439.839966f, 61.1151123f, -219.030579f, -404.7129f);
+            bool4x2 r3 = bool4x2(false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_equal_wide_scalar()
+        {
+            float4x2 a0 = float4x2(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f, -410.870056f, -483.902649f);
+            float b0 = (292.924255f);
+            bool4x2 r0 = bool4x2(false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x2 a1 = float4x2(183.821167f, -257.870056f, -386.801758f, -182.938812f, 349.250122f, 485.311584f, 373.5691f, 259.1515f);
+            float b1 = (320.4425f);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x2 a2 = float4x2(450.130066f, -43.8748779f, 457.385742f, -77.6383057f, 479.451843f, -499.516449f, -398.132935f, 402.484863f);
+            float b2 = (-128.525543f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x2 a3 = float4x2(87.91608f, 125.950806f, -54.49362f, 250.667419f, 97.94293f, 228.021545f, -213.378662f, 42.2608032f);
+            float b3 = (-502.1736f);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float4x2 b0 = float4x2(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f, 288.5443f, 304.042847f);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (-148.618073f);
+            float4x2 b1 = float4x2(-506.3001f, 27.5812378f, 48.47113f, 104.883484f, -488.685852f, -480.435181f, 421.936646f, 239.721069f);
+            bool4x2 r1 = bool4x2(false, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-101.018433f);
+            float4x2 b2 = float4x2(-283.951477f, -55.24353f, -455.80484f, 131.107239f, -461.6988f, -388.482849f, -258.936035f, -225.223541f);
+            bool4x2 r2 = bool4x2(false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (-116.019989f);
+            float4x2 b3 = float4x2(-442.595245f, 297.333374f, 36.6872559f, 485.097839f, 344.445679f, 237.592163f, 230.390869f, -413.9848f);
+            bool4x2 r3 = bool4x2(false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_equal_wide_wide()
+        {
+            float4x2 a0 = float4x2(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f, -122.535187f, 7.48144531f);
+            float4x2 b0 = float4x2(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f, -373.302063f, 364.9359f);
+            bool4x2 r0 = bool4x2(false, false, true, false, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x2 a1 = float4x2(152.946411f, 48.9862061f, 57.3381348f, 300.4649f, 349.25708f, 85.7496948f, -230.953308f, 418.711243f);
+            float4x2 b1 = float4x2(-322.7154f, 125.47821f, -25.77658f, 297.518921f, 73.22235f, 462.783752f, 393.191345f, -95.0014343f);
+            bool4x2 r1 = bool4x2(true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x2 a2 = float4x2(-131.039917f, -126.512207f, -156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f);
+            float4x2 b2 = float4x2(381.357056f, 93.03192f, 254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f);
+            bool4x2 r2 = bool4x2(false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x2 a3 = float4x2(-223.492981f, 302.123f, 459.852722f, -347.128021f, 364.9781f, 212.635437f, 504.276062f, -142.232971f);
+            float4x2 b3 = float4x2(453.684875f, -154.011658f, -97.29007f, 151.184753f, 57.36029f, -194.207092f, -462.670624f, 113.3866f);
+            bool4x2 r3 = bool4x2(false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_equal_wide_scalar()
+        {
+            float4x2 a0 = float4x2(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f, 53.8151245f, -123.332947f);
+            float b0 = (189.205139f);
+            bool4x2 r0 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x2 a1 = float4x2(-221.505463f, -116.440369f, -395.3633f, 164.772583f, -287.007324f, 355.837036f, 184.195557f, 273.012268f);
+            float b1 = (252.994324f);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x2 a2 = float4x2(-418.1424f, 396.392151f, 332.6654f, 243.761414f, -335.12146f, -302.0869f, 254.442261f, 179.005066f);
+            float b2 = (249.3841f);
+            bool4x2 r2 = bool4x2(false, true, true, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x2 a3 = float4x2(71.1767f, 307.890564f, -388.578522f, 150.605774f, -219.892578f, -491.681f, 30.99707f, 199.232239f);
+            float b3 = (-331.271667f);
+            bool4x2 r3 = bool4x2(true, true, false, true, true, false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float4x2 b0 = float4x2(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f, -455.612579f, 276.665833f);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (79.39917f);
+            float4x2 b1 = float4x2(416.420532f, 379.2735f, -439.5147f, 67.14099f, -74.56064f, -367.256348f, 494.950745f, -61.2355347f);
+            bool4x2 r1 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (-429.170258f);
+            float4x2 b2 = float4x2(-213.824677f, -264.310181f, 243.11377f, -22.38388f, 304.862f, -323.686157f, 67.93805f, 125.303589f);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (-400.47052f);
+            float4x2 b3 = float4x2(-283.159637f, -42.31961f, -429.510376f, 499.395874f, -289.963074f, -136.008789f, -351.125244f, -381.8183f);
+            bool4x2 r3 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_add_wide_wide()
+        {
+            float4x2 a0 = float4x2(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f, -470.536774f, -109.9501f);
+            float4x2 b0 = float4x2(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f, 267.49176f, 251.642517f);
+            float4x2 r0 = float4x2(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f, -203.045013f, 141.692413f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x2 a1 = float4x2(-178.701447f, -420.033783f, 290.711121f, -446.529633f, 491.066467f, -261.1173f, -298.4069f, 502.4286f);
+            float4x2 b1 = float4x2(244.495117f, -78.67575f, 352.2055f, 82.7791748f, 462.5473f, -405.492f, -428.498322f, -41.87259f);
+            float4x2 r1 = float4x2(65.79367f, -498.709534f, 642.9166f, -363.750458f, 953.6138f, -666.6093f, -726.9052f, 460.556f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x2 a2 = float4x2(284.5943f, 401.128418f, -36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f);
+            float4x2 b2 = float4x2(-269.9275f, 75.20447f, -141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f);
+            float4x2 r2 = float4x2(14.6668091f, 476.3329f, -178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x2 a3 = float4x2(-62.8800049f, -79.5522461f, 413.098267f, -100.877594f, 418.524f, -183.143127f, 407.443726f, 300.486023f);
+            float4x2 b3 = float4x2(492.692444f, 439.043823f, -511.742767f, -399.057129f, -315.868469f, -228.07724f, -171.7052f, 467.17395f);
+            float4x2 r3 = float4x2(429.812439f, 359.491577f, -98.6445f, -499.934723f, 102.655518f, -411.220367f, 235.738525f, 767.66f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_add_wide_scalar()
+        {
+            float4x2 a0 = float4x2(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f, -2.79125977f, -478.4148f);
+            float b0 = (500.997253f);
+            float4x2 r0 = float4x2(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f, 498.206f, 22.5824585f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x2 a1 = float4x2(443.115234f, 41.3210449f, -471.256073f, -2.664978f, 78.98584f, 202.14801f, 311.725464f, 10.3458252f);
+            float b1 = (268.092224f);
+            float4x2 r1 = float4x2(711.207458f, 309.413269f, -203.163849f, 265.427246f, 347.078064f, 470.240234f, 579.8177f, 278.438049f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x2 a2 = float4x2(-151.244446f, -197.800751f, 255.955261f, 244.1471f, -181.626556f, -2.45492554f, 300.900635f, -236.491943f);
+            float b2 = (355.2328f);
+            float4x2 r2 = float4x2(203.988342f, 157.432037f, 611.188049f, 599.3799f, 173.606232f, 352.777863f, 656.1334f, 118.740845f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x2 a3 = float4x2(-160.5841f, -242.9411f, 466.344116f, 237.987488f, 264.294f, 372.866821f, -198.837769f, -381.930969f);
+            float b3 = (-172.5422f);
+            float4x2 r3 = float4x2(-333.1263f, -415.4833f, 293.8019f, 65.44528f, 91.7518f, 200.324615f, -371.379974f, -554.473145f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float4x2 b0 = float4x2(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f, 180.318115f, 337.579346f);
+            float4x2 r0 = float4x2(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f, -145.194641f, 12.0665894f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (-37.0550232f);
+            float4x2 b1 = float4x2(230.805f, -140.174347f, 18.02417f, -138.614349f, 26.9041748f, -374.5376f, 154.46759f, 268.38385f);
+            float4x2 r1 = float4x2(193.749969f, -177.22937f, -19.0308533f, -175.669373f, -10.1508484f, -411.592621f, 117.412567f, 231.328827f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (-190.963013f);
+            float4x2 b2 = float4x2(188.617249f, -504.916138f, 20.45404f, 197.945374f, 251.411926f, -421.0904f, 111.445374f, -73.26889f);
+            float4x2 r2 = float4x2(-2.34576416f, -695.87915f, -170.508972f, 6.982361f, 60.4489136f, -612.0534f, -79.51764f, -264.2319f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (480.884583f);
+            float4x2 b3 = float4x2(438.05304f, 66.8443f, -270.796021f, -44.02191f, 197.6947f, 19.1139526f, 349.2378f, 366.2345f);
+            float4x2 r3 = float4x2(918.9376f, 547.7289f, 210.088562f, 436.862671f, 678.5793f, 499.998535f, 830.1224f, 847.1191f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_sub_wide_wide()
+        {
+            float4x2 a0 = float4x2(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f, 146.506592f, -130.585052f);
+            float4x2 b0 = float4x2(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f, -125.6055f, -65.29901f);
+            float4x2 r0 = float4x2(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f, 272.1121f, -65.28604f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x2 a1 = float4x2(110.7771f, -235.5416f, 78.87933f, -347.686157f, -470.820557f, -11.45929f, -167.9479f, 330.676758f);
+            float4x2 b1 = float4x2(-477.876434f, 164.5f, 428.009583f, 72.62781f, -446.8805f, 432.091431f, -225.554657f, -112.451965f);
+            float4x2 r1 = float4x2(588.653564f, -400.0416f, -349.130249f, -420.313965f, -23.9400635f, -443.55072f, 57.60675f, 443.128723f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x2 a2 = float4x2(-508.350861f, -252.031891f, -427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f);
+            float4x2 b2 = float4x2(-210.6128f, -172.925049f, -80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f);
+            float4x2 r2 = float4x2(-297.738068f, -79.10684f, -347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x2 a3 = float4x2(-308.939575f, 454.5334f, 26.1069336f, -482.711823f, -40.8535461f, 318.380676f, 475.210815f, 134.926941f);
+            float4x2 b3 = float4x2(-221.325439f, -9.25882f, 288.173828f, 217.36145f, 307.540039f, -262.412659f, -405.378021f, 400.004333f);
+            float4x2 r3 = float4x2(-87.6141357f, 463.7922f, -262.0669f, -700.073242f, -348.3936f, 580.793335f, 880.588867f, -265.0774f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_sub_wide_scalar()
+        {
+            float4x2 a0 = float4x2(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f, 204.358337f, 180.269714f);
+            float b0 = (-291.5904f);
+            float4x2 r0 = float4x2(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f, 495.94873f, 471.8601f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x2 a1 = float4x2(-377.9257f, 400.5349f, 461.507568f, -246.287262f, 21.6052856f, 246.350708f, -121.427368f, -122.718414f);
+            float b1 = (-470.262054f);
+            float4x2 r1 = float4x2(92.3363647f, 870.797f, 931.769653f, 223.9748f, 491.86734f, 716.6128f, 348.8347f, 347.54364f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x2 a2 = float4x2(-122.938721f, 342.874573f, 18.92981f, 164.602356f, 97.0437f, 485.914978f, -205.75766f, 253.443237f);
+            float b2 = (360.15094f);
+            float4x2 r2 = float4x2(-483.089661f, -17.2763672f, -341.22113f, -195.548584f, -263.107239f, 125.764038f, -565.908569f, -106.7077f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x2 a3 = float4x2(-121.163055f, -450.820282f, -248.073364f, -26.9960632f, 441.5526f, 449.910583f, 354.886047f, 98.82147f);
+            float b3 = (187.998413f);
+            float4x2 r3 = float4x2(-309.161469f, -638.8187f, -436.071777f, -214.994476f, 253.5542f, 261.91217f, 166.887634f, -89.17694f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float4x2 b0 = float4x2(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f, -64.233f, -66.04172f);
+            float4x2 r0 = float4x2(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f, 358.8195f, 360.6282f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (341.204956f);
+            float4x2 b1 = float4x2(-385.775055f, 75.3947754f, 354.943726f, 169.131409f, 88.21661f, 1.73498535f, 122.538025f, -264.945f);
+            float4x2 r1 = float4x2(726.98f, 265.810181f, -13.73877f, 172.073547f, 252.988342f, 339.469971f, 218.666931f, 606.149963f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (-50.83719f);
+            float4x2 b2 = float4x2(-347.65033f, 4.06555176f, -79.09543f, 354.358337f, -292.4925f, -53.2089844f, -246.3476f, 299.203369f);
+            float4x2 r2 = float4x2(296.813141f, -54.90274f, 28.25824f, -405.195526f, 241.6553f, 2.37179565f, 195.5104f, -350.040558f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (432.1847f);
+            float4x2 b3 = float4x2(-163.88f, 176.742554f, -104.98584f, -445.797638f, -28.8731689f, -169.588226f, -270.359253f, 68.04761f);
+            float4x2 r3 = float4x2(596.0647f, 255.442139f, 537.170532f, 877.9823f, 461.057861f, 601.772949f, 702.543945f, 364.1371f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mul_wide_wide()
+        {
+            float4x2 a0 = float4x2(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f, 494.688477f, 53.5379639f);
+            float4x2 b0 = float4x2(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f, 207.732422f, 366.192871f);
+            float4x2 r0 = float4x2(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f, 102762.836f, 19605.22f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x2 a1 = float4x2(-239.4964f, 236.675842f, -211.8562f, -216.654816f, 467.9583f, -178.021912f, -386.394257f, -422.4354f);
+            float4x2 b1 = float4x2(358.880737f, 214.853577f, 253.422791f, -307.7138f, 184.47113f, 426.436462f, -144.281433f, 459.4796f);
+            float4x2 r1 = float4x2(-85950.64f, 50850.6523f, -53689.19f, 66667.68f, 86324.8f, -75915.03f, 55749.5156f, -194100.453f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x2 a2 = float4x2(464.589539f, -251.315674f, -104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f);
+            float4x2 b2 = float4x2(-358.313354f, -201.3652f, 254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f);
+            float4x2 r2 = float4x2(-166468.641f, 50606.23f, -26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x2 a3 = float4x2(-83.11417f, 329.960266f, -316.972168f, 474.937927f, -445.109161f, -301.003723f, 405.687866f, 142.373474f);
+            float4x2 b3 = float4x2(-189.746918f, -35.5184631f, 120.31665f, -136.203339f, 407.3416f, 301.6543f, -155.482391f, -461.394562f);
+            float4x2 r3 = float4x2(15770.6572f, -11719.6816f, -38137.03f, -64688.1328f, -181311.484f, -90799.07f, -63077.32f, -65690.34f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mul_wide_scalar()
+        {
+            float4x2 a0 = float4x2(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f, -477.3105f, -438.272919f);
+            float b0 = (192.211182f);
+            float4x2 r0 = float4x2(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f, -91744.4141f, -84240.95f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x2 a1 = float4x2(-46.729187f, 422.08252f, -48.83484f, 355.30835f, 119.356628f, -196.995819f, 98.23602f, -325.552155f);
+            float b1 = (-238.405f);
+            float4x2 r1 = float4x2(11140.4717f, -100626.586f, 11642.47f, -84707.29f, -28455.2168f, 46964.79f, -23419.959f, 77613.26f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x2 a2 = float4x2(53.9373169f, -130.474121f, -222.594574f, 126.015015f, 293.361084f, 174.381958f, -327.120056f, 56.62915f);
+            float b2 = (-87.45099f);
+            float4x2 r2 = float4x2(-4716.87158f, 11410.0908f, 19466.1152f, -11020.1377f, -25654.7168f, -15249.875f, 28606.9727f, -4952.27539f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x2 a3 = float4x2(257.541565f, -452.6919f, -49.22061f, 141.600952f, 431.5857f, 180.355164f, -40.9234619f, 279.543518f);
+            float b3 = (-475.6087f);
+            float4x2 r3 = float4x2(-122489.008f, 215304.2f, 23409.752f, -67346.65f, -205265.9f, -85778.4844f, 19463.5547f, -132953.328f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float4x2 b0 = float4x2(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f, 159.748108f, -351.8222f);
+            float4x2 r0 = float4x2(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f, -74208.54f, 163433.625f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (491.801575f);
+            float4x2 b1 = float4x2(49.90204f, 424.4626f, 160.1181f, -395.9921f, 125.20166f, -265.0158f, 314.656128f, -292.712036f);
+            float4x2 r1 = float4x2(24541.9f, 208751.375f, 78746.3359f, -194749.531f, 61574.375f, -130335.195f, 154748.375f, -143956.234f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (-37.72989f);
+            float4x2 b2 = float4x2(165.362244f, 356.517761f, -188.813324f, 504.9157f, 40.5721436f, -206.775116f, -61.60269f, 118.971619f);
+            float4x2 r2 = float4x2(-6239.099f, -13451.376f, 7123.906f, -19050.4141f, -1530.78247f, 7801.602f, 2324.2627f, -4488.786f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (53.7483521f);
+            float4x2 b3 = float4x2(-198.6694f, 96.236084f, -20.2418823f, -31.1239624f, 38.89044f, -13.1333008f, 507.871277f, 95.0179443f);
+            float4x2 r3 = float4x2(-10678.1533f, 5172.531f, -1087.96777f, -1672.86169f, 2090.297f, -705.89325f, 27297.2441f, 5107.058f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_div_wide_wide()
+        {
+            float4x2 a0 = float4x2(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f, 360.41864f, 25.8097534f);
+            float4x2 b0 = float4x2(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f, -93.2107849f, -442.005219f);
+            float4x2 r0 = float4x2(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x2 a1 = float4x2(-274.050476f, 127.538574f, -447.671753f, -137.458588f, -136.133179f, 12.4376221f, 228.513f, 356.972351f);
+            float4x2 b1 = float4x2(484.362732f, -390.7818f, 402.02533f, 316.6507f, 397.154419f, -303.2622f, -118.591248f, -81.6503f);
+            float4x2 r1 = float4x2(-0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f, -0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x2 a2 = float4x2(-24.7620544f, 411.6684f, -204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f);
+            float4x2 b2 = float4x2(-84.34686f, -488.419434f, 404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f);
+            float4x2 r2 = float4x2(0.2935741f, -0.8428584f, -0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x2 a3 = float4x2(315.37384f, -122.665985f, 447.526123f, -210.4815f, -202.42157f, -453.007935f, 173.72699f, -167.121674f);
+            float4x2 b3 = float4x2(-218.209686f, 458.517517f, 119.587219f, 356.240417f, -74.50687f, -336.773926f, -216.126312f, 322.385681f);
+            float4x2 r3 = float4x2(-1.44527888f, -0.267527372f, 3.742257f, -0.5908412f, 2.71681762f, 1.34513962f, -0.803821564f, -0.5183905f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_div_wide_scalar()
+        {
+            float4x2 a0 = float4x2(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f, 131.526611f, -261.8864f);
+            float b0 = (-60.0243835f);
+            float4x2 r0 = float4x2(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f, -2.19121981f, 4.36300039f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x2 a1 = float4x2(-348.9238f, 210.557922f, 287.6424f, 504.372253f, 491.7871f, -26.6315918f, -253.236664f, 272.895142f);
+            float b1 = (-275.5387f);
+            float4x2 r1 = float4x2(1.26633322f, -0.764168262f, -1.04392743f, -1.83049512f, -1.78482044f, 0.09665282f, 0.91906023f, -0.990405858f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x2 a2 = float4x2(178.096191f, -502.646027f, -84.3248f, -174.690338f, 83.7963257f, 197.042053f, 317.168274f, 403.387146f);
+            float b2 = (-460.87558f);
+            float4x2 r2 = float4x2(-0.386430085f, 1.0906328f, 0.182966515f, 0.379040122f, -0.181819841f, -0.427538484f, -0.688186347f, -0.875262558f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x2 a3 = float4x2(81.6464844f, -413.5605f, 207.341f, 358.562134f, 20.7490845f, -68.57712f, 310.702454f, 417.4049f);
+            float b3 = (60.6068726f);
+            float4x2 r3 = float4x2(1.3471489f, -6.82365656f, 3.42108083f, 5.916196f, 0.3423553f, -1.13150728f, 5.12652159f, 6.887089f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float4x2 b0 = float4x2(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f, 333.6645f, 38.2910767f);
+            float4x2 r0 = float4x2(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f, 0.125088736f, 1.0900104f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (-472.979767f);
+            float4x2 b1 = float4x2(192.230164f, -200.296875f, -490.181519f, -211.10257f, -322.852356f, -137.985291f, 84.32971f, 355.063477f);
+            float4x2 r1 = float4x2(-2.46048665f, 2.36139369f, 0.9649074f, 2.24052119f, 1.46500325f, 3.42775488f, -5.60869646f, -1.3320992f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (276.427246f);
+            float4x2 b2 = float4x2(-382.988037f, -488.647156f, 344.846f, 168.85498f, -44.1955872f, 420.55072f, -175.6152f, -9.220581f);
+            float4x2 r2 = float4x2(-0.7217647f, -0.5656991f, 0.801596165f, 1.637069f, -6.25463438f, 0.6572982f, -1.57405078f, -29.9793739f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-344.194275f);
+            float4x2 b3 = float4x2(-449.0715f, 117.704895f, -337.0274f, 239.393433f, -389.355164f, 242.716064f, 496.2765f, 91.74579f);
+            float4x2 r3 = float4x2(0.7664576f, -2.924214f, 1.02126491f, -1.43777657f, 0.8840111f, -1.41809428f, -0.693553448f, -3.75160837f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mod_wide_wide()
+        {
+            float4x2 a0 = float4x2(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f, -101.348572f, 208.318542f);
+            float4x2 b0 = float4x2(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f, 487.0462f, -469.8291f);
+            float4x2 r0 = float4x2(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f, -101.348572f, 208.318542f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x2 a1 = float4x2(-140.770325f, 183.44696f, -463.368378f, 83.83911f, -64.71405f, 295.066833f, 212.25708f, 349.6283f);
+            float4x2 b1 = float4x2(-145.203766f, -203.384f, -22.52008f, 224.69f, -435.62674f, 12.0955811f, 40.3787842f, 345.784851f);
+            float4x2 r1 = float4x2(-140.770325f, 183.44696f, -12.9667664f, 83.83911f, -64.71405f, 4.772888f, 10.3631592f, 3.84344482f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x2 a2 = float4x2(119.875916f, -37.8058167f, 142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f);
+            float4x2 b2 = float4x2(-433.471252f, -355.649963f, 4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f);
+            float4x2 r2 = float4x2(119.875916f, -37.8058167f, 1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x2 a3 = float4x2(156.985718f, 507.6183f, 270.830444f, 337.7343f, 384.915833f, 432.5182f, 154.292725f, -37.0853271f);
+            float4x2 b3 = float4x2(-131.4183f, -473.9876f, 76.2178345f, 92.2102051f, -368.189575f, -77.46716f, 135.230591f, 274.277283f);
+            float4x2 r3 = float4x2(25.5674133f, 33.6306763f, 42.17694f, 61.1037f, 16.7262573f, 45.182373f, 19.0621338f, -37.0853271f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mod_wide_scalar()
+        {
+            float4x2 a0 = float4x2(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f, -450.807678f, 186.094788f);
+            float b0 = (-90.49924f);
+            float4x2 r0 = float4x2(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f, -88.81073f, 5.09631348f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x2 a1 = float4x2(-84.47363f, 433.4547f, -54.60019f, -172.338867f, -429.714661f, 222.361877f, 5.79638672f, 254.5108f);
+            float b1 = (-318.7815f);
+            float4x2 r1 = float4x2(-84.47363f, 114.673218f, -54.60019f, -172.338867f, -110.933167f, 222.361877f, 5.79638672f, 254.5108f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x2 a2 = float4x2(-433.0937f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 483.5506f, -331.993347f);
+            float b2 = (-203.082611f);
+            float4x2 r2 = float4x2(-26.9284668f, -75.3564148f, 49.2065125f, -69.4039f, 5.337219f, -75.97781f, 77.385376f, -128.910736f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x2 a3 = float4x2(336f, -124.720764f, 38.1759033f, 271.287f, 405.773621f, -194.761444f, 235.724f, 465.984863f);
+            float b3 = (67.8396f);
+            float4x2 r3 = float4x2(64.6416f, -56.8811646f, 38.1759033f, 67.76819f, 66.57562f, -59.0822449f, 32.2052f, 58.9472656f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float4x2 b0 = float4x2(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f, 397.0448f, -393.890656f);
+            float4x2 r0 = float4x2(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f, -396.4224f, -2.53173828f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (-372.067078f);
+            float4x2 b1 = float4x2(201.012268f, -95.566864f, -258.951477f, 106.983582f, 469.323547f, -34.80899f, 184.836548f, 374.79425f);
+            float4x2 r1 = float4x2(-171.05481f, -85.3664856f, -113.1156f, -51.116333f, -372.067078f, -23.9771729f, -2.393982f, -372.067078f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (-131.872711f);
+            float4x2 b2 = float4x2(-120.092865f, 4.506653f, -111.401947f, 391.54248f, -218.668884f, 196.377441f, -511.032623f, 499.9535f);
+            float4x2 r2 = float4x2(-11.7798462f, -1.179779f, -20.4707642f, -131.872711f, -131.872711f, -131.872711f, -131.872711f, -131.872711f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (-433.523071f);
+            float4x2 b3 = float4x2(-163.866852f, 177.004028f, 110.650146f, 17.68457f, -95.85297f, -432.440979f, 192.692078f, -268.131775f);
+            float4x2 r3 = float4x2(-105.789368f, -79.5150146f, -101.572632f, -9.093384f, -50.1112061f, -1.08209229f, -48.138916f, -165.3913f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_plus()
+        {
+            float4x2 a0 = float4x2(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f);
+            float4x2 r0 = float4x2(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float4x2 a1 = float4x2(-320.518463f, -107.00351f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f, 465.355957f);
+            float4x2 r1 = float4x2(-320.518463f, -107.00351f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f, 465.355957f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float4x2 a2 = float4x2(309.59314f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f);
+            float4x2 r2 = float4x2(309.59314f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float4x2 a3 = float4x2(239.152344f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f);
+            float4x2 r3 = float4x2(239.152344f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_neg()
+        {
+            float4x2 a0 = float4x2(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f, -495.837952f, -270.859467f);
+            float4x2 r0 = float4x2(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f, 495.837952f, 270.859467f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float4x2 a1 = float4x2(19.68689f, -180.600525f, 223.381287f, -410.392059f, -395.681549f, -349.149475f, -110.9393f, -238.2196f);
+            float4x2 r1 = float4x2(-19.68689f, 180.600525f, -223.381287f, 410.392059f, 395.681549f, 349.149475f, 110.9393f, 238.2196f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float4x2 a2 = float4x2(292.543518f, 48.29071f, 88.7237549f, 66.1485f, 55.7080078f, 464.541382f, 499.2428f, 175.015015f);
+            float4x2 r2 = float4x2(-292.543518f, -48.29071f, -88.7237549f, -66.1485f, -55.7080078f, -464.541382f, -499.2428f, -175.015015f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float4x2 a3 = float4x2(196.387573f, 149.660034f, 320.391724f, -359.8338f, 22.0384521f, -159.55426f, 419.822449f, 303.323425f);
+            float4x2 r3 = float4x2(-196.387573f, -149.660034f, -320.391724f, 359.8338f, -22.0384521f, 159.55426f, -419.822449f, -303.323425f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_prefix_inc()
+        {
+            float4x2 a0 = float4x2(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f, -323.614868f, -456.8903f);
+            float4x2 r0 = float4x2(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f, -322.614868f, -455.8903f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float4x2 a1 = float4x2(-76.50766f, 64.0965f, 148.679321f, 363.2849f, -115.559235f, -326.8778f, -179.894653f, 339.8766f);
+            float4x2 r1 = float4x2(-75.50766f, 65.0965f, 149.679321f, 364.2849f, -114.559235f, -325.8778f, -178.894653f, 340.8766f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float4x2 a2 = float4x2(-38.41043f, 261.625549f, 155.030823f, -396.650238f, 301.3058f, -221.355408f, -429.698151f, -271.2893f);
+            float4x2 r2 = float4x2(-37.41043f, 262.625549f, 156.030823f, -395.650238f, 302.3058f, -220.355408f, -428.698151f, -270.2893f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float4x2 a3 = float4x2(-264.380066f, 223.232422f, -71.076355f, -388.2279f, 131.283142f, 22.3049316f, -480.760468f, 200.951782f);
+            float4x2 r3 = float4x2(-263.380066f, 224.232422f, -70.076355f, -387.2279f, 132.283142f, 23.3049316f, -479.760468f, 201.951782f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_postfix_inc()
+        {
+            float4x2 a0 = float4x2(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f);
+            float4x2 r0 = float4x2(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float4x2 a1 = float4x2(153.7503f, -427.401062f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f, -170.104645f);
+            float4x2 r1 = float4x2(153.7503f, -427.401062f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f, -170.104645f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float4x2 a2 = float4x2(-270.652466f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f);
+            float4x2 r2 = float4x2(-270.652466f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float4x2 a3 = float4x2(188.006592f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f);
+            float4x2 r3 = float4x2(188.006592f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_prefix_dec()
+        {
+            float4x2 a0 = float4x2(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f, 337.968933f, 246.088989f);
+            float4x2 r0 = float4x2(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f, 336.968933f, 245.088989f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float4x2 a1 = float4x2(171.964539f, 298.2848f, 326.5078f, 400.7209f, -478.031372f, -326.452972f, -24.5845032f, 112.796875f);
+            float4x2 r1 = float4x2(170.964539f, 297.2848f, 325.5078f, 399.7209f, -479.031372f, -327.452972f, -25.5845032f, 111.796875f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float4x2 a2 = float4x2(-341.9763f, -79.6352539f, -131.00415f, 147.893677f, -15.7086487f, 188.758423f, 307.791931f, -406.667725f);
+            float4x2 r2 = float4x2(-342.9763f, -80.6352539f, -132.00415f, 146.893677f, -16.7086487f, 187.758423f, 306.791931f, -407.667725f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float4x2 a3 = float4x2(181.4751f, -505.2157f, -372.241943f, -4.031769f, 83.76776f, -30.6314087f, -436.906555f, -51.668396f);
+            float4x2 r3 = float4x2(180.4751f, -506.2157f, -373.241943f, -5.031769f, 82.76776f, -31.6314087f, -437.906555f, -52.668396f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x2_operator_postfix_dec()
+        {
+            float4x2 a0 = float4x2(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f);
+            float4x2 r0 = float4x2(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float4x2 a1 = float4x2(-182.405731f, -129.232666f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f, 378.641235f);
+            float4x2 r1 = float4x2(-182.405731f, -129.232666f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f, 378.641235f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float4x2 a2 = float4x2(487.344849f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f);
+            float4x2 r2 = float4x2(487.344849f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float4x2 a3 = float4x2(311.299f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f);
+            float4x2 r3 = float4x2(311.299f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..bc296688facc10a2567968568f0c91a3da6e5294
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 24d6c72f4a165e342afb784bad62cab5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..1c9dfc57c510bd5405367aa80892d195cc41581f
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs
@@ -0,0 +1,949 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat4x3
+    {
+        [TestCompiler]
+        public static void float4x3_zero()
+        {
+            TestUtils.AreEqual(float4x3.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c0.w, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c1.z, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c1.w, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c2.x, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c2.y, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c2.z, 0.0f);
+            TestUtils.AreEqual(float4x3.zero.c2.w, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_equal_wide_wide()
+        {
+            float4x3 a0 = float4x3(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f, 177.924438f, 335.5334f, 168.15448f, 350.729553f, 367.178467f, 46.9414673f);
+            float4x3 b0 = float4x3(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f, -72.44382f, 362.97644f, 194.678345f, 471.644836f, -404.044678f, -144.696747f);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x3 a1 = float4x3(188.76416f, -97.2113953f, -293.320984f, -234.822937f, 417.0337f, 26.3864136f, 269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f);
+            float4x3 b1 = float4x3(-494.446655f, -252.970367f, 234.417114f, 398.724f, 260.4287f, 370.144226f, 89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x3 a2 = float4x3(-22.98944f, 487.260864f, -419.731964f, 337.2033f, 245.043884f, 390.215881f, 84.4129639f, 434.2079f, -68.7284241f, 485.769958f, 413.169739f, -418.2693f);
+            float4x3 b2 = float4x3(-174.081818f, 395.101135f, 350.3393f, -243.144592f, -416.397369f, 151.576477f, -18.2243347f, -431.677917f, -468.330963f, 429.495728f, 477.389221f, -433.4254f);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x3 a3 = float4x3(-346.795868f, 504.159668f, 345.186279f, -434.713043f, -499.7741f, 282.019043f, 259.15625f, 306.455933f, 435.2254f, -386.8997f, 211.364014f, -7.229828f);
+            float4x3 b3 = float4x3(273.5464f, -34.9762268f, 221.968445f, 85.91913f, -85.59894f, 392.7608f, -117.924072f, -445.3056f, -242.468964f, 173.643066f, 389.897766f, -14.2904663f);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_equal_wide_scalar()
+        {
+            float4x3 a0 = float4x3(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f, 314.671265f, 386.365173f, 290.04895f, -132.6352f, -65.66748f, -69.68326f);
+            float b0 = (-155.815765f);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x3 a1 = float4x3(-191.190765f, -232.895691f, -319.144043f, -49.70108f, -300.8819f, 333.396851f, 386.3775f, -296.7019f, -309.1172f, 141.542358f, -227.323334f, 83.87286f);
+            float b1 = (186.845215f);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x3 a2 = float4x3(-410.91687f, -390.103577f, 36.57434f, -427.541443f, -268.170837f, 175.8117f, -193.47995f, 291.051941f, 423.97168f, -429.8739f, -275.156952f, -56.3323669f);
+            float b2 = (110.501282f);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x3 a3 = float4x3(-95.83597f, 253.006165f, -300.509521f, 314.866516f, 195.616211f, -26.1289063f, -284.7747f, -242.672058f, 140.3606f, 505.644348f, 506.537964f, -502.3698f);
+            float b3 = (-124.865326f);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float4x3 b0 = float4x3(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f, 428.311951f, -489.501343f, -5.691559f, -30.8659363f, -362.9831f, 184.503174f);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (-160.470612f);
+            float4x3 b1 = float4x3(316.668823f, 390.369263f, 505.1051f, -294.6487f, 443.1991f, 96.5592651f, -257.012939f, -245.054962f, 326.464844f, -23.9599f, -168.694885f, 386.2486f);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (-227.090637f);
+            float4x3 b2 = float4x3(-336.612427f, 365.108154f, -405.390839f, -473.995483f, 298.435364f, -149.86322f, 450.0664f, 153.47644f, 56.28778f, 39.3421021f, -350.403717f, -482.717224f);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (239.9654f);
+            float4x3 b3 = float4x3(-3.40603638f, -1.49484253f, 105.960449f, 151.537537f, 63.2832031f, -289.693176f, 137.553772f, -247.666473f, -339.420563f, 23.2382813f, 21.1778564f, 477.03656f);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_not_equal_wide_wide()
+        {
+            float4x3 a0 = float4x3(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f, 366.081543f, 154.542847f, 332.4262f, 397.11322f, -431.374969f, 489.0108f);
+            float4x3 b0 = float4x3(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f, -457.730225f, -59.5232544f, 3.024231f, 155.812744f, -19.8399048f, -6.01693726f);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x3 a1 = float4x3(398.4336f, -489.817932f, 171.4049f, -67.82968f, -192.278717f, 227.84082f, 62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f);
+            float4x3 b1 = float4x3(-406.207916f, -102.420715f, -40.362915f, 452.6754f, 93.25757f, -258.378052f, -184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x3 a2 = float4x3(-72.20682f, 444.749268f, 238.81781f, 365.1801f, -437.9229f, -362.442627f, 445.954346f, -0.417480469f, -506.828369f, 245.477051f, -173.571045f, 390.338562f);
+            float4x3 b2 = float4x3(415.071716f, -467.726135f, -433.784668f, -212.165924f, 474.674927f, 452.483215f, -92.11273f, -385.9221f, 420.2151f, -239.176056f, -99.0791f, 4.476013f);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x3 a3 = float4x3(252.837769f, 47.8658447f, 457.7105f, -313.22113f, 391.203857f, 481.786133f, 26.8878174f, -298.1424f, 240.077454f, -332.455139f, -333.607178f, -313.1897f);
+            float4x3 b3 = float4x3(264.348572f, 451.312317f, 232.958008f, -142.6222f, -300.2256f, 268.333252f, -112.103546f, -270.494019f, -71.9932251f, 99.46326f, 321.7033f, 200.059631f);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_not_equal_wide_scalar()
+        {
+            float4x3 a0 = float4x3(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f, -58.92328f, -398.176849f, 492.20105f, -165.241516f, 270.341f, -380.243256f);
+            float b0 = (-393.413544f);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x3 a1 = float4x3(501.899048f, 458.400452f, 46.7709961f, 161.459961f, 261.514221f, -145.6124f, -0.449920654f, 350.461426f, 202.221008f, 242.664f, 382.677063f, -468.967957f);
+            float b1 = (-134.345459f);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x3 a2 = float4x3(-497.459473f, -328.587769f, -506.490326f, 449.348145f, 210.771f, 249.181824f, -338.468536f, 229.670654f, -76.5433044f, 317.286072f, 401.939575f, 210.984863f);
+            float b2 = (-80.93225f);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x3 a3 = float4x3(-147.096313f, 207.731384f, 284.3921f, -509.0853f, 414.307617f, -52.2944641f, -140.437927f, -316.787781f, -358.696838f, 312.31897f, 270.629456f, -140.016724f);
+            float b3 = (-193.399048f);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float4x3 b0 = float4x3(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f, -338.100128f, -152.314545f, -452.820679f, 209.439331f, 50.10797f, 372.4344f);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-488.0213f);
+            float4x3 b1 = float4x3(489.740784f, 270.4001f, -472.846771f, -286.850464f, -384.691864f, 443.423523f, 358.7472f, -15.4140625f, -342.179169f, 468.967529f, -130.568085f, 401.785828f);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (-268.352264f);
+            float4x3 b2 = float4x3(-239.231018f, 411.386536f, 139.769348f, 334.522034f, -223.629242f, -12.4884644f, 113.468872f, -189.652252f, -212.846558f, 306.1256f, -178.330383f, 382.141968f);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (-340.8656f);
+            float4x3 b3 = float4x3(-17.58023f, -409.874847f, -349.70166f, 275.8543f, -229.371948f, -127.505737f, 90.75342f, -422.087128f, -2.44754028f, -280.5517f, -484.374359f, -33.7634277f);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_wide_wide()
+        {
+            float4x3 a0 = float4x3(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f, 3.38293457f, -144.301331f, -69.3696f, -135.667969f, -194.787354f, -33.473877f);
+            float4x3 b0 = float4x3(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f, 231.906311f, 179.49884f, 473.2249f, 15.8916626f, 270.049927f, 490.914f);
+            bool4x3 r0 = bool4x3(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x3 a1 = float4x3(-19.67508f, 423.237976f, -71.6983f, -501.886f, 7.64386f, 302.262878f, -140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f);
+            float4x3 b1 = float4x3(-185.734131f, 76.4331055f, 97.75232f, 419.300781f, 73.953186f, 481.032349f, 7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x3 a2 = float4x3(269.1078f, 462.98822f, 223.884155f, -287.18924f, 283.6386f, 511.864319f, -60.4967957f, -234.303467f, -316.1384f, -417.522156f, 441.643433f, -191.950623f);
+            float4x3 b2 = float4x3(-382.315857f, 251.535156f, 143.17395f, 293.660339f, -292.769562f, -43.2182f, -353.4112f, 458.32605f, -114.556458f, 441.429749f, -113.333679f, 435.622925f);
+            bool4x3 r2 = bool4x3(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x3 a3 = float4x3(397.811584f, -144.666626f, 417.079041f, -322.980133f, -81.2850952f, 319.325317f, 146.764038f, -316.583374f, -150.857544f, -314.606323f, 7.14312744f, -458.8273f);
+            float4x3 b3 = float4x3(383.656128f, -293.7116f, -391.35498f, 43.12201f, 433.223633f, -201.382446f, -241.421173f, 376.469849f, -503.39743f, -359.780945f, 118.631531f, -510.030518f);
+            bool4x3 r3 = bool4x3(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_wide_scalar()
+        {
+            float4x3 a0 = float4x3(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f, 282.9666f, 258.2791f, -111.413147f, -288.081116f, 82.6654053f, -361.6429f);
+            float b0 = (199.0675f);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x3 a1 = float4x3(-68.0881958f, -66.703064f, -78.76297f, 25.7277222f, 101.37085f, -330.442657f, -48.9205322f, 359.604431f, -8.150085f, 241.2768f, -183.437775f, 423.027161f);
+            float b1 = (12.7880249f);
+            bool4x3 r1 = bool4x3(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x3 a2 = float4x3(-334.622742f, 300.410156f, 297.925232f, -492.108154f, -395.807251f, 95.78882f, -220.62146f, -455.37558f, 360.291565f, -296.372131f, 272.488342f, 360.207947f);
+            float b2 = (-98.31558f);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x3 a3 = float4x3(389.727417f, -400.615234f, -85.46912f, -467.702148f, -51.38788f, 201.764648f, -47.8412781f, -180.740051f, -409.0157f, 229.699036f, 176.197876f, -410.45517f);
+            float b3 = (68.7366943f);
+            bool4x3 r3 = bool4x3(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float4x3 b0 = float4x3(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f, -299.744324f, 31.4371338f, -458.904541f, 13.6846924f, -458.5069f, 248.276489f);
+            bool4x3 r0 = bool4x3(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (389.231445f);
+            float4x3 b1 = float4x3(488.745544f, -221.637878f, -424.2672f, 249.059021f, -22.1361389f, -442.247742f, -340.857544f, -95.1117249f, 15.4094238f, 87.29248f, 495.067627f, 316.0185f);
+            bool4x3 r1 = bool4x3(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (-125.568115f);
+            float4x3 b2 = float4x3(122.164795f, 96.75537f, -228.906342f, -143.9527f, -230.238281f, -327.6126f, 103.39801f, 434.488831f, -157.4502f, 190.572144f, 108.2583f, 132.550781f);
+            bool4x3 r2 = bool4x3(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-431.515228f);
+            float4x3 b3 = float4x3(-192.203522f, -431.835f, -85.58124f, 328.670532f, 273.577881f, -178.669067f, 352.6363f, -82.6058044f, 238.908875f, 291.335327f, 183.357361f, -185.0326f);
+            bool4x3 r3 = bool4x3(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_wide_wide()
+        {
+            float4x3 a0 = float4x3(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f, -396.770355f, 127.037415f, 489.1399f, 51.9188843f, 155.384766f, -135.631653f);
+            float4x3 b0 = float4x3(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f, -391.096039f, 479.283752f, -77.6748657f, -46.584198f, -415.377f, 71.46698f);
+            bool4x3 r0 = bool4x3(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x3 a1 = float4x3(-425.978149f, -228.430511f, 383.03833f, 136.533569f, 8.602417f, -251.324371f, -345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f);
+            float4x3 b1 = float4x3(-206.061035f, 360.8363f, 236.968811f, 14.550354f, 364.735168f, -159.06131f, 226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x3 a2 = float4x3(105.535217f, -170.9253f, 26.9802246f, -188.928314f, 201.786621f, -506.057159f, 15.454895f, 115.080688f, -496.971832f, 339.888123f, 372.228333f, 313.2387f);
+            float4x3 b2 = float4x3(-352.1598f, 9.822632f, 186.721619f, -325.913635f, -77.93036f, -379.746033f, 251.45575f, -144.183563f, 337.8899f, -249.505554f, -225.9013f, -249.491272f);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x3 a3 = float4x3(-419.108948f, -265.329773f, -42.5019836f, 369.163879f, 67.16907f, -256.6989f, -104.105927f, 499.570129f, 41.6635132f, 151.1521f, 220.688354f, -344.658875f);
+            float4x3 b3 = float4x3(381.122864f, 325.5454f, 455.49884f, 333.318665f, 118.980347f, 223.19812f, -385.289063f, 333.8808f, -437.4107f, 243.975464f, -302.8199f, -32.7101746f);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_wide_scalar()
+        {
+            float4x3 a0 = float4x3(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f, 173.575073f, 69.26929f, 501.306824f, -367.027771f, -86.12451f, -489.090576f);
+            float b0 = (-302.816956f);
+            bool4x3 r0 = bool4x3(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x3 a1 = float4x3(-172.518158f, -236.414948f, -238.8945f, -27.2391357f, 471.779358f, 240.164551f, -481.4781f, 185.59436f, 33.29474f, -510.228149f, -183.2862f, -386.127655f);
+            float b1 = (-18.1496277f);
+            bool4x3 r1 = bool4x3(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x3 a2 = float4x3(-13.6382141f, -261.865967f, 52.24951f, 16.3232422f, -410.5101f, -262.2675f, -458.255981f, -218.866119f, -34.6923523f, 290.573059f, 180.2633f, -482.863953f);
+            float b2 = (-7.34790039f);
+            bool4x3 r2 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x3 a3 = float4x3(100.7063f, 501.319763f, -289.280975f, -25.8497f, 455.1624f, -63.3173523f, -17.4467773f, 53.01776f, 88.81958f, 182.357971f, -428.927216f, 408.336853f);
+            float b3 = (180.672546f);
+            bool4x3 r3 = bool4x3(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float4x3 b0 = float4x3(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f, 176.409241f, -140.440033f, -182.48288f, -158.2933f, -162.685333f, -193.328674f);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (230.181274f);
+            float4x3 b1 = float4x3(-102.58783f, 392.520569f, -177.478668f, -10.2950134f, -24.04895f, 172.448669f, 374.048035f, -368.99762f, -210.195282f, 149.470215f, -281.343262f, -100.469177f);
+            bool4x3 r1 = bool4x3(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (304.864441f);
+            float4x3 b2 = float4x3(-361.524841f, -372.452362f, -33.9095459f, -69.5952759f, -460.4324f, -309.341675f, 486.131531f, 471.920959f, 479.361572f, -107.004181f, 331.636536f, -340.840149f);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (-384.2146f);
+            float4x3 b3 = float4x3(-451.726563f, 467.97876f, -236.569122f, 44.6547241f, -285.797852f, 42.730957f, 338.18512f, 274.017029f, -108.60437f, -211.37326f, -19.00415f, 194.114685f);
+            bool4x3 r3 = bool4x3(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_equal_wide_wide()
+        {
+            float4x3 a0 = float4x3(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f, 294.6701f, -327.564453f, -456.12326f, 282.30127f, 421.881165f, -311.71283f);
+            float4x3 b0 = float4x3(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f, 74.41406f, 260.916138f, 306.173279f, 139.564819f, -505.752472f, -489.6268f);
+            bool4x3 r0 = bool4x3(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x3 a1 = float4x3(84.5675049f, 447.244629f, -154.494354f, -424.364746f, 36.68451f, 267.0703f, 307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f);
+            float4x3 b1 = float4x3(-280.0326f, 303.1599f, 511.1902f, -104.659729f, 95.14661f, -125.636353f, 376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x3 a2 = float4x3(-77.04346f, 438.1848f, 260.282349f, 386.034058f, -281.491f, -102.930054f, -346.716736f, -258.3412f, -383.302948f, -5.14703369f, 319.34375f, 465.022217f);
+            float4x3 b2 = float4x3(-216.002319f, 66.73425f, 99.21863f, 233.843018f, 439.839966f, 61.1151123f, -219.030579f, -404.7129f, -202.748352f, -312.476471f, 310.0719f, -320.363037f);
+            bool4x3 r2 = bool4x3(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x3 a3 = float4x3(145.933472f, -215.074829f, -146.461517f, -349.893982f, 29.5991211f, -131.796631f, -438.9947f, 147.057922f, 221.112488f, -356.145355f, -32.83017f, 442.942017f);
+            float4x3 b3 = float4x3(186.075989f, -42.6377869f, 82.56506f, 127.189087f, 198.286987f, -450.492035f, 20.901001f, 449.465881f, -478.7727f, 380.053955f, 99.1247559f, -450.329773f);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_equal_wide_scalar()
+        {
+            float4x3 a0 = float4x3(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f, -410.870056f, -483.902649f, 183.821167f, 320.4425f, -257.870056f, -386.801758f);
+            float b0 = (292.924255f);
+            bool4x3 r0 = bool4x3(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x3 a1 = float4x3(-182.938812f, 485.311584f, 373.5691f, 259.1515f, 450.130066f, -128.525543f, -43.8748779f, 457.385742f, -77.6383057f, 479.451843f, -499.516449f, -398.132935f);
+            float b1 = (349.250122f);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x3 a2 = float4x3(402.484863f, -502.1736f, 125.950806f, -54.49362f, 250.667419f, 97.94293f, 228.021545f, -213.378662f, 42.2608032f, -24.8275757f, -451.0416f, 429.577576f);
+            float b2 = (87.91608f);
+            bool4x3 r2 = bool4x3(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x3 a3 = float4x3(-308.4343f, -279.4071f, 181.672241f, -290.148743f, -184.844086f, 447.6939f, 168.8866f, 26.3789673f, 392.558533f, 255.604858f, 162.163452f, 195.496277f);
+            float b3 = (355.160339f);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float4x3 b0 = float4x3(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f, 288.5443f, 304.042847f, -148.618073f, -506.3001f, 27.5812378f, 48.47113f);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (104.883484f);
+            float4x3 b1 = float4x3(-488.685852f, -480.435181f, 421.936646f, 239.721069f, -101.018433f, -283.951477f, -55.24353f, -455.80484f, 131.107239f, -461.6988f, -388.482849f, -258.936035f);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (-225.223541f);
+            float4x3 b2 = float4x3(-116.019989f, -442.595245f, 297.333374f, 36.6872559f, 485.097839f, 344.445679f, 237.592163f, 230.390869f, -413.9848f, -215.901672f, 39.5603638f, 22.947998f);
+            bool4x3 r2 = bool4x3(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (-162.060577f);
+            float4x3 b3 = float4x3(236.7337f, -253.951965f, -204.719086f, -161.616547f, -64.3859253f, -229.815643f, -484.825653f, -135.040436f, 351.694763f, 111.825378f, -249.982544f, 435.8073f);
+            bool4x3 r3 = bool4x3(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_equal_wide_wide()
+        {
+            float4x3 a0 = float4x3(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f, -122.535187f, 7.48144531f, 152.946411f, 48.9862061f, 57.3381348f, 300.4649f);
+            float4x3 b0 = float4x3(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f, -373.302063f, 364.9359f, -322.7154f, 125.47821f, -25.77658f, 297.518921f);
+            bool4x3 r0 = bool4x3(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x3 a1 = float4x3(349.25708f, 85.7496948f, -230.953308f, 418.711243f, -131.039917f, -126.512207f, -156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f);
+            float4x3 b1 = float4x3(73.22235f, 462.783752f, 393.191345f, -95.0014343f, 381.357056f, 93.03192f, 254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x3 a2 = float4x3(-223.492981f, 302.123f, 459.852722f, -347.128021f, 364.9781f, 212.635437f, 504.276062f, -142.232971f, -132.2218f, 303.683777f, 265.210144f, 9.754395f);
+            float4x3 b2 = float4x3(453.684875f, -154.011658f, -97.29007f, 151.184753f, 57.36029f, -194.207092f, -462.670624f, 113.3866f, -129.3533f, 8.107788f, 426.449524f, 410.693176f);
+            bool4x3 r2 = bool4x3(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x3 a3 = float4x3(-233.0929f, 26.5675049f, 266.7807f, -250.072235f, 138.040833f, 174.276733f, -420.931641f, -42.8541565f, 216.485046f, 240.053833f, -470.382172f, 98.39673f);
+            float4x3 b3 = float4x3(470.313416f, 220.399963f, -372.872681f, -242.178558f, 177.506226f, -172.638153f, 60.72284f, 478.250183f, 234.30304f, 297.821228f, 104.584595f, -462.418732f);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_equal_wide_scalar()
+        {
+            float4x3 a0 = float4x3(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f, 53.8151245f, -123.332947f, -221.505463f, 252.994324f, -116.440369f, -395.3633f);
+            float b0 = (189.205139f);
+            bool4x3 r0 = bool4x3(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x3 a1 = float4x3(164.772583f, 355.837036f, 184.195557f, 273.012268f, -418.1424f, 249.3841f, 396.392151f, 332.6654f, 243.761414f, -335.12146f, -302.0869f, 254.442261f);
+            float b1 = (-287.007324f);
+            bool4x3 r1 = bool4x3(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x3 a2 = float4x3(179.005066f, -331.271667f, 307.890564f, -388.578522f, 150.605774f, -219.892578f, -491.681f, 30.99707f, 199.232239f, -74.50003f, -343.386475f, 216.031555f);
+            float b2 = (71.1767f);
+            bool4x3 r2 = bool4x3(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x3 a3 = float4x3(-420.403137f, -336.6411f, 317.0946f, -262.424927f, -228.411255f, 123.465454f, 264.102478f, 223.623352f, 440.5354f, -420.727f, 74.8443f, -177.077881f);
+            float b3 = (-78.38403f);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float4x3 b0 = float4x3(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f, -455.612579f, 276.665833f, 79.39917f, 416.420532f, 379.2735f, -439.5147f);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (67.14099f);
+            float4x3 b1 = float4x3(-74.56064f, -367.256348f, 494.950745f, -61.2355347f, -429.170258f, -213.824677f, -264.310181f, 243.11377f, -22.38388f, 304.862f, -323.686157f, 67.93805f);
+            bool4x3 r1 = bool4x3(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (125.303589f);
+            float4x3 b2 = float4x3(-400.47052f, -283.159637f, -42.31961f, -429.510376f, 499.395874f, -289.963074f, -136.008789f, -351.125244f, -381.8183f, 393.3009f, 18.02362f, -169.92392f);
+            bool4x3 r2 = bool4x3(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (-285.884949f);
+            float4x3 b3 = float4x3(163.7511f, 191.855347f, 114.0155f, -395.98584f, 189.366577f, 176.19812f, 61.7138062f, 507.548462f, 224.043823f, -422.9937f, -127.054993f, 95.5286255f);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_add_wide_wide()
+        {
+            float4x3 a0 = float4x3(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f, -470.536774f, -109.9501f, -178.701447f, -420.033783f, 290.711121f, -446.529633f);
+            float4x3 b0 = float4x3(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f, 267.49176f, 251.642517f, 244.495117f, -78.67575f, 352.2055f, 82.7791748f);
+            float4x3 r0 = float4x3(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f, -203.045013f, 141.692413f, 65.79367f, -498.709534f, 642.9166f, -363.750458f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x3 a1 = float4x3(491.066467f, -261.1173f, -298.4069f, 502.4286f, 284.5943f, 401.128418f, -36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f);
+            float4x3 b1 = float4x3(462.5473f, -405.492f, -428.498322f, -41.87259f, -269.9275f, 75.20447f, -141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f);
+            float4x3 r1 = float4x3(953.6138f, -666.6093f, -726.9052f, 460.556f, 14.6668091f, 476.3329f, -178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x3 a2 = float4x3(-62.8800049f, -79.5522461f, 413.098267f, -100.877594f, 418.524f, -183.143127f, 407.443726f, 300.486023f, -261.126129f, -309.830353f, 378.363342f, -224.094f);
+            float4x3 b2 = float4x3(492.692444f, 439.043823f, -511.742767f, -399.057129f, -315.868469f, -228.07724f, -171.7052f, 467.17395f, -474.822937f, 311.390747f, 326.8454f, 475.2119f);
+            float4x3 r2 = float4x3(429.812439f, 359.491577f, -98.6445f, -499.934723f, 102.655518f, -411.220367f, 235.738525f, 767.66f, -735.9491f, 1.56039429f, 705.20874f, 251.11792f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x3 a3 = float4x3(-164.555725f, -69.87393f, 224.634644f, -383.9926f, 149.221252f, 169.388f, 163.053955f, 57.0291138f, 342.950073f, 168.680481f, -470.770264f, -117.630493f);
+            float4x3 b3 = float4x3(314.152954f, -262.594635f, -82.86911f, 156.299561f, 427.40155f, -279.099365f, -448.615234f, 284.3371f, 288.1856f, -232.39505f, -386.871918f, 162.903381f);
+            float4x3 r3 = float4x3(149.597229f, -332.468567f, 141.765533f, -227.693054f, 576.6228f, -109.711365f, -285.561279f, 341.3662f, 631.1357f, -63.71457f, -857.6422f, 45.27289f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_add_wide_scalar()
+        {
+            float4x3 a0 = float4x3(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f, -2.79125977f, -478.4148f, 443.115234f, 268.092224f, 41.3210449f, -471.256073f);
+            float b0 = (500.997253f);
+            float4x3 r0 = float4x3(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f, 498.206f, 22.5824585f, 944.1125f, 769.0895f, 542.3183f, 29.74118f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x3 a1 = float4x3(-2.664978f, 202.14801f, 311.725464f, 10.3458252f, -151.244446f, 355.2328f, -197.800751f, 255.955261f, 244.1471f, -181.626556f, -2.45492554f, 300.900635f);
+            float b1 = (78.98584f);
+            float4x3 r1 = float4x3(76.32086f, 281.13385f, 390.7113f, 89.331665f, -72.258606f, 434.218628f, -118.814911f, 334.9411f, 323.132935f, -102.640717f, 76.5309143f, 379.886475f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x3 a2 = float4x3(-236.491943f, -172.5422f, -242.9411f, 466.344116f, 237.987488f, 264.294f, 372.866821f, -198.837769f, -381.930969f, 402.160339f, -117.024841f, 497.373779f);
+            float b2 = (-160.5841f);
+            float4x3 r2 = float4x3(-397.07605f, -333.1263f, -403.5252f, 305.76f, 77.40338f, 103.7099f, 212.282715f, -359.421875f, -542.5151f, 241.576233f, -277.608948f, 336.789673f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x3 a3 = float4x3(485.9093f, 77.81482f, -271.547974f, -133.2518f, 211.86676f, 253.1502f, -342.783173f, -185.248352f, -403.3855f, -358.848236f, 65.24756f, 127.201721f);
+            float b3 = (-47.75714f);
+            float4x3 r3 = float4x3(438.152161f, 30.0576782f, -319.3051f, -181.008942f, 164.109619f, 205.393066f, -390.5403f, -233.0055f, -451.142639f, -406.605377f, 17.4904175f, 79.44458f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float4x3 b0 = float4x3(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f, 180.318115f, 337.579346f, -37.0550232f, 230.805f, -140.174347f, 18.02417f);
+            float4x3 r0 = float4x3(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f, -145.194641f, 12.0665894f, -362.56778f, -94.70776f, -465.6871f, -307.4886f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (-138.614349f);
+            float4x3 b1 = float4x3(26.9041748f, -374.5376f, 154.46759f, 268.38385f, -190.963013f, 188.617249f, -504.916138f, 20.45404f, 197.945374f, 251.411926f, -421.0904f, 111.445374f);
+            float4x3 r1 = float4x3(-111.710175f, -513.152f, 15.853241f, 129.7695f, -329.577362f, 50.0029f, -643.5305f, -118.160309f, 59.3310242f, 112.797577f, -559.7047f, -27.1689758f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (-73.26889f);
+            float4x3 b2 = float4x3(480.884583f, 438.05304f, 66.8443f, -270.796021f, -44.02191f, 197.6947f, 19.1139526f, 349.2378f, 366.2345f, -413.4803f, -260.720184f, 77.54236f);
+            float4x3 r2 = float4x3(407.6157f, 364.784149f, -6.424591f, -344.0649f, -117.2908f, 124.425812f, -54.1549377f, 275.9689f, 292.9656f, -486.749176f, -333.989075f, 4.273468f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (183.9549f);
+            float4x3 b3 = float4x3(-51.4989929f, -472.497467f, 107.126892f, 349.0772f, 431.595947f, -314.110962f, 396.996643f, -167.308624f, -157.114532f, 287.7625f, -367.33905f, 96.23682f);
+            float4x3 r3 = float4x3(132.4559f, -288.542572f, 291.0818f, 533.0321f, 615.550842f, -130.156067f, 580.951538f, 16.64627f, 26.8403625f, 471.7174f, -183.384155f, 280.1917f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_sub_wide_wide()
+        {
+            float4x3 a0 = float4x3(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f, 146.506592f, -130.585052f, 110.7771f, -235.5416f, 78.87933f, -347.686157f);
+            float4x3 b0 = float4x3(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f, -125.6055f, -65.29901f, -477.876434f, 164.5f, 428.009583f, 72.62781f);
+            float4x3 r0 = float4x3(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f, 272.1121f, -65.28604f, 588.653564f, -400.0416f, -349.130249f, -420.313965f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x3 a1 = float4x3(-470.820557f, -11.45929f, -167.9479f, 330.676758f, -508.350861f, -252.031891f, -427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f);
+            float4x3 b1 = float4x3(-446.8805f, 432.091431f, -225.554657f, -112.451965f, -210.6128f, -172.925049f, -80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f);
+            float4x3 r1 = float4x3(-23.9400635f, -443.55072f, 57.60675f, 443.128723f, -297.738068f, -79.10684f, -347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x3 a2 = float4x3(-308.939575f, 454.5334f, 26.1069336f, -482.711823f, -40.8535461f, 318.380676f, 475.210815f, 134.926941f, 388.481567f, 138.7182f, -385.5736f, -149.3648f);
+            float4x3 b2 = float4x3(-221.325439f, -9.25882f, 288.173828f, 217.36145f, 307.540039f, -262.412659f, -405.378021f, 400.004333f, 72.11908f, -154.880585f, -469.659973f, -320.615417f);
+            float4x3 r2 = float4x3(-87.6141357f, 463.7922f, -262.0669f, -700.073242f, -348.3936f, 580.793335f, 880.588867f, -265.0774f, 316.3625f, 293.5988f, 84.0863647f, 171.25061f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x3 a3 = float4x3(-158.534058f, 508.070679f, 482.7008f, 114.569275f, 364.83136f, 229.031f, -168.088074f, 373.4411f, -239.90097f, 379.928467f, 113.011841f, 306.835266f);
+            float4x3 b3 = float4x3(6.41229248f, -278.865051f, 15.8380737f, 27.51831f, 429.869629f, -458.622467f, -172.064423f, -284.524719f, 42.60669f, -223.474243f, -56.92975f, 61.807312f);
+            float4x3 r3 = float4x3(-164.94635f, 786.9357f, 466.862732f, 87.0509644f, -65.03827f, 687.653442f, 3.97634888f, 657.9658f, -282.50766f, 603.4027f, 169.941589f, 245.027954f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_sub_wide_scalar()
+        {
+            float4x3 a0 = float4x3(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f, 204.358337f, 180.269714f, -377.9257f, -470.262054f, 400.5349f, 461.507568f);
+            float b0 = (-291.5904f);
+            float4x3 r0 = float4x3(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f, 495.94873f, 471.8601f, -86.3353f, -178.671661f, 692.1253f, 753.097961f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x3 a1 = float4x3(-246.287262f, 246.350708f, -121.427368f, -122.718414f, -122.938721f, 360.15094f, 342.874573f, 18.92981f, 164.602356f, 97.0437f, 485.914978f, -205.75766f);
+            float b1 = (21.6052856f);
+            float4x3 r1 = float4x3(-267.892548f, 224.745422f, -143.032654f, -144.3237f, -144.544f, 338.545654f, 321.2693f, -2.675476f, 142.99707f, 75.4384155f, 464.3097f, -227.362946f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x3 a2 = float4x3(253.443237f, 187.998413f, -450.820282f, -248.073364f, -26.9960632f, 441.5526f, 449.910583f, 354.886047f, 98.82147f, -189.193237f, 269.074829f, -59.11856f);
+            float b2 = (-121.163055f);
+            float4x3 r2 = float4x3(374.6063f, 309.161469f, -329.657227f, -126.910309f, 94.16699f, 562.7157f, 571.0736f, 476.0491f, 219.984528f, -68.03018f, 390.237885f, 62.0444946f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x3 a3 = float4x3(363.458374f, -46.1552124f, 109.913269f, 182.646912f, 229.015747f, -144.92868f, 469.2506f, -150.49231f, -192.3125f, -224.356842f, 285.876831f, -63.0108337f);
+            float b3 = (-73.7792053f);
+            float4x3 r3 = float4x3(437.237579f, 27.6239929f, 183.692474f, 256.426117f, 302.794952f, -71.1494751f, 543.0298f, -76.7131042f, -118.533295f, -150.577637f, 359.656036f, 10.7683716f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float4x3 b0 = float4x3(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f, -64.233f, -66.04172f, 341.204956f, -385.775055f, 75.3947754f, 354.943726f);
+            float4x3 r0 = float4x3(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f, 358.8195f, 360.6282f, -46.61847f, 680.3616f, 219.191711f, -60.35724f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (169.131409f);
+            float4x3 b1 = float4x3(88.21661f, 1.73498535f, 122.538025f, -264.945f, -50.83719f, -347.65033f, 4.06555176f, -79.09543f, 354.358337f, -292.4925f, -53.2089844f, -246.3476f);
+            float4x3 r1 = float4x3(80.9147949f, 167.396423f, 46.5933838f, 434.076416f, 219.9686f, 516.781738f, 165.065857f, 248.226837f, -185.226929f, 461.6239f, 222.3404f, 415.479f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (299.203369f);
+            float4x3 b2 = float4x3(432.1847f, -163.88f, 176.742554f, -104.98584f, -445.797638f, -28.8731689f, -169.588226f, -270.359253f, 68.04761f, -65.53128f, 440.380371f, 427.360657f);
+            float4x3 r2 = float4x3(-132.981323f, 463.083374f, 122.460815f, 404.1892f, 745.001f, 328.076538f, 468.7916f, 569.5626f, 231.155762f, 364.73465f, -141.177f, -128.157288f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (-81.47296f);
+            float4x3 b3 = float4x3(41.7131958f, 175.8208f, -214.949158f, -163.446869f, -218.829132f, 389.116882f, -74.10977f, -448.137238f, -410.375f, 363.211f, -263.5354f, 473.546021f);
+            float4x3 r3 = float4x3(-123.186157f, -257.293762f, 133.4762f, 81.97391f, 137.356171f, -470.589844f, -7.3631897f, 366.664276f, 328.902039f, -444.68396f, 182.062439f, -555.019f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mul_wide_wide()
+        {
+            float4x3 a0 = float4x3(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f, 494.688477f, 53.5379639f, -239.4964f, 236.675842f, -211.8562f, -216.654816f);
+            float4x3 b0 = float4x3(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f, 207.732422f, 366.192871f, 358.880737f, 214.853577f, 253.422791f, -307.7138f);
+            float4x3 r0 = float4x3(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f, 102762.836f, 19605.22f, -85950.64f, 50850.6523f, -53689.19f, 66667.68f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x3 a1 = float4x3(467.9583f, -178.021912f, -386.394257f, -422.4354f, 464.589539f, -251.315674f, -104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f);
+            float4x3 b1 = float4x3(184.47113f, 426.436462f, -144.281433f, 459.4796f, -358.313354f, -201.3652f, 254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f);
+            float4x3 r1 = float4x3(86324.8f, -75915.03f, 55749.5156f, -194100.453f, -166468.641f, 50606.23f, -26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x3 a2 = float4x3(-83.11417f, 329.960266f, -316.972168f, 474.937927f, -445.109161f, -301.003723f, 405.687866f, 142.373474f, -416.213074f, -103.279205f, -52.9519043f, -40.82834f);
+            float4x3 b2 = float4x3(-189.746918f, -35.5184631f, 120.31665f, -136.203339f, 407.3416f, 301.6543f, -155.482391f, -461.394562f, 296.680359f, 341.001831f, -257.0968f, 17.5936279f);
+            float4x3 r2 = float4x3(15770.6572f, -11719.6816f, -38137.03f, -64688.1328f, -181311.484f, -90799.07f, -63077.32f, -65690.34f, -123482.242f, -35218.4f, 13613.7656f, -718.3186f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x3 a3 = float4x3(-86.18509f, -257.316528f, 363.857239f, -229.860016f, 8.925293f, -2.44940186f, 37.7583f, 264.451782f, -321.251282f, -268.256042f, 43.9136963f, 274.833069f);
+            float4x3 b3 = float4x3(-443.845123f, 291.349243f, 490.19165f, 361.320984f, -509.289734f, 315.352661f, 125.083069f, -167.727112f, 396.8877f, -0.320404053f, 143.4115f, -396.3475f);
+            float4x3 r3 = float4x3(38252.832f, -74968.98f, 178359.781f, -83053.25f, -4545.56f, -772.4254f, 4722.92432f, -44355.7344f, -127500.68f, 85.950325f, 6297.729f, -108929.4f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mul_wide_scalar()
+        {
+            float4x3 a0 = float4x3(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f, -477.3105f, -438.272919f, -46.729187f, -238.405f, 422.08252f, -48.83484f);
+            float b0 = (192.211182f);
+            float4x3 r0 = float4x3(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f, -91744.4141f, -84240.95f, -8981.872f, -45824.1055f, 81128.98f, -9386.603f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x3 a1 = float4x3(355.30835f, -196.995819f, 98.23602f, -325.552155f, 53.9373169f, -87.45099f, -130.474121f, -222.594574f, 126.015015f, 293.361084f, 174.381958f, -327.120056f);
+            float b1 = (119.356628f);
+            float4x3 r1 = float4x3(42408.4063f, -23512.7559f, 11725.12f, -38856.81f, 6437.77637f, -10437.8555f, -15572.9512f, -26568.1387f, 15040.7275f, 35014.59f, 20813.6426f, -39043.9453f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x3 a2 = float4x3(56.62915f, -475.6087f, -452.6919f, -49.22061f, 141.600952f, 431.5857f, 180.355164f, -40.9234619f, 279.543518f, 120.014465f, -59.508667f, 319.489868f);
+            float b2 = (257.541565f);
+            float4x3 r2 = float4x3(14584.36f, -122489.008f, -116586.977f, -12676.3535f, 36468.13f, 111151.258f, 46448.95f, -10539.4922f, 71994.08f, 30908.7129f, -15325.9551f, 82281.92f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x3 a3 = float4x3(-403.523163f, -335.3932f, -364.242554f, 150.686157f, 391.87207f, 179.312439f, 354.5298f, 497.7614f, 418.436584f, -413.333374f, -329.520721f, -322.703064f);
+            float b3 = (-408.1931f);
+            float4x3 r3 = float4x3(164715.375f, 136905.188f, 148681.3f, -61509.05f, -159959.484f, -73194.1f, -144716.625f, -203182.781f, -170802.938f, 168719.844f, 134508.1f, 131725.172f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float4x3 b0 = float4x3(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f, 159.748108f, -351.8222f, 491.801575f, 49.90204f, 424.4626f, 160.1181f);
+            float4x3 r0 = float4x3(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f, -74208.54f, 163433.625f, -228458.891f, -23181.2285f, -197177.6f, -74380.4141f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (-395.9921f);
+            float4x3 b1 = float4x3(125.20166f, -265.0158f, 314.656128f, -292.712036f, -37.72989f, 165.362244f, 356.517761f, -188.813324f, 504.9157f, 40.5721436f, -206.775116f, -61.60269f);
+            float4x3 r1 = float4x3(-49578.8672f, 104944.164f, -124601.336f, 115911.656f, 14940.7373f, -65482.14f, -141178.219f, 74768.5859f, -199942.625f, -16066.248f, 81881.31f, 24394.18f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (118.971619f);
+            float4x3 b2 = float4x3(53.7483521f, -198.6694f, 96.236084f, -20.2418823f, -31.1239624f, 38.89044f, -13.1333008f, 507.871277f, 95.0179443f, 340.7486f, 438.986877f, -227.165955f);
+            float4x3 r2 = float4x3(6394.52832f, -23636.02f, 11449.3623f, -2408.20947f, -3702.86816f, 4626.859f, -1562.49011f, 60422.27f, 11304.4385f, 40539.41f, 52226.98f, -27026.3f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (452.573f);
+            float4x3 b3 = float4x3(144.014954f, -31.58603f, 42.29773f, -466.027161f, 287.453979f, 328.9969f, -164.243134f, -511.2683f, -9.594299f, 431.190125f, -132.141815f, -87.502655f);
+            float4x3 r3 = float4x3(65177.28f, -14294.9834f, 19142.81f, -210911.313f, 130093.906f, 148895.109f, -74332.01f, -231386.234f, -4342.12061f, 195145f, -59803.8164f, -39601.34f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_div_wide_wide()
+        {
+            float4x3 a0 = float4x3(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f, 360.41864f, 25.8097534f, -274.050476f, 127.538574f, -447.671753f, -137.458588f);
+            float4x3 b0 = float4x3(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f, -93.2107849f, -442.005219f, 484.362732f, -390.7818f, 402.02533f, 316.6507f);
+            float4x3 r0 = float4x3(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f, -0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x3 a1 = float4x3(-136.133179f, 12.4376221f, 228.513f, 356.972351f, -24.7620544f, 411.6684f, -204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f);
+            float4x3 b1 = float4x3(397.154419f, -303.2622f, -118.591248f, -81.6503f, -84.34686f, -488.419434f, 404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f);
+            float4x3 r1 = float4x3(-0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f, 0.2935741f, -0.8428584f, -0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x3 a2 = float4x3(315.37384f, -122.665985f, 447.526123f, -210.4815f, -202.42157f, -453.007935f, 173.72699f, -167.121674f, -106.234528f, 414.312561f, 7.12084961f, 274.073669f);
+            float4x3 b2 = float4x3(-218.209686f, 458.517517f, 119.587219f, 356.240417f, -74.50687f, -336.773926f, -216.126312f, 322.385681f, 220.2555f, -67.2345f, 2.229187f, -166.210968f);
+            float4x3 r2 = float4x3(-1.44527888f, -0.267527372f, 3.742257f, -0.5908412f, 2.71681762f, 1.34513962f, -0.803821564f, -0.5183905f, -0.482324064f, -6.16220236f, 3.19437075f, -1.64895058f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x3 a3 = float4x3(-39.0026855f, 39.065918f, -147.364166f, 434.3849f, 315.0672f, -106.636017f, -507.925262f, -17.1764526f, -385.865356f, 226.002136f, 345.168457f, 201.544189f);
+            float4x3 b3 = float4x3(-247.732574f, 84.16095f, 477.148621f, 209.7508f, -386.7222f, -65.27734f, 410.454834f, 367.6507f, -456.572021f, 382.427979f, -163.860687f, -213.721375f);
+            float4x3 r3 = float4x3(0.157438666f, 0.464181036f, -0.3088433f, 2.07095718f, -0.814712f, 1.6335839f, -1.23746932f, -0.0467194878f, 0.8451358f, 0.5909665f, -2.106475f, -0.9430231f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_div_wide_scalar()
+        {
+            float4x3 a0 = float4x3(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f, 131.526611f, -261.8864f, -348.9238f, -275.5387f, 210.557922f, 287.6424f);
+            float b0 = (-60.0243835f);
+            float4x3 r0 = float4x3(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f, -2.19121981f, 4.36300039f, 5.813034f, 4.590446f, -3.507873f, -4.79209232f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x3 a1 = float4x3(504.372253f, -26.6315918f, -253.236664f, 272.895142f, 178.096191f, -460.87558f, -502.646027f, -84.3248f, -174.690338f, 83.7963257f, 197.042053f, 317.168274f);
+            float b1 = (491.7871f);
+            float4x3 r1 = float4x3(1.02559066f, -0.0541526824f, -0.5149315f, 0.554905057f, 0.362140834f, -0.9371445f, -1.02208054f, -0.171466067f, -0.355215371f, 0.17039147f, 0.400665343f, 0.64493f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x3 a2 = float4x3(403.387146f, 60.6068726f, -413.5605f, 207.341f, 358.562134f, 20.7490845f, -68.57712f, 310.702454f, 417.4049f, 147.866211f, 506.658875f, -435.778564f);
+            float b2 = (81.6464844f);
+            float4x3 r2 = float4x3(4.940655f, 0.742308438f, -5.06525755f, 2.539497f, 4.391642f, 0.254133224f, -0.8399274f, 3.80546021f, 5.112344f, 1.81105423f, 6.20551968f, -5.33738327f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x3 a3 = float4x3(210.672913f, -19.1908569f, 416.511719f, 427.0136f, 417.1994f, -150.911835f, 488.985535f, -294.738739f, -357.298035f, 288.771667f, 453.429138f, 70.72443f);
+            float b3 = (-218.781464f);
+            float4x3 r3 = float4x3(-0.962937653f, 0.08771701f, -1.90377975f, -1.95178151f, -1.90692294f, 0.689783454f, -2.235041f, 1.34718335f, 1.63312757f, -1.31990921f, -2.07252073f, -0.323265165f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float4x3 b0 = float4x3(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f, 333.6645f, 38.2910767f, -472.979767f, 192.230164f, -200.296875f, -490.181519f);
+            float4x3 r0 = float4x3(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f, 0.125088736f, 1.0900104f, -0.0882440954f, 0.217123419f, -0.208379045f, -0.08514738f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (-211.10257f);
+            float4x3 b1 = float4x3(-322.852356f, -137.985291f, 84.32971f, 355.063477f, 276.427246f, -382.988037f, -488.647156f, 344.846f, 168.85498f, -44.1955872f, 420.55072f, -175.6152f);
+            float4x3 r1 = float4x3(0.6538672f, 1.52989185f, -2.5033f, -0.5945488f, -0.7636822f, 0.55119884f, 0.432014316f, -0.612164736f, -1.25020039f, 4.776553f, -0.501966953f, 1.20207453f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (-9.220581f);
+            float4x3 b2 = float4x3(-344.194275f, -449.0715f, 117.704895f, -337.0274f, 239.393433f, -389.355164f, 242.716064f, 496.2765f, 91.74579f, -490.492126f, 485.755432f, -317.572266f);
+            float4x3 r2 = float4x3(0.0267888848f, 0.0205325447f, -0.0783364251f, 0.02735855f, -0.038516432f, 0.0236816723f, -0.0379891656f, -0.018579524f, -0.100501411f, 0.0187986325f, -0.018981941f, 0.0290345922f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-451.6248f);
+            float4x3 b3 = float4x3(394.018372f, -262.271423f, -314.246765f, 359.9159f, -101.615356f, 359.517273f, -424.9799f, -192.719574f, -169.749725f, -244.790009f, -187.14386f, -207.713654f);
+            float4x3 r3 = float4x3(-1.14620233f, 1.72197485f, 1.43716609f, -1.2548064f, 4.444454f, -1.25619769f, 1.06269681f, 2.3434298f, 2.66053319f, 1.84494781f, 2.41324925f, 2.17426634f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mod_wide_wide()
+        {
+            float4x3 a0 = float4x3(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -463.368378f, 83.83911f);
+            float4x3 b0 = float4x3(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f, 487.0462f, -469.8291f, -145.203766f, -203.384f, -22.52008f, 224.69f);
+            float4x3 r0 = float4x3(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -12.9667664f, 83.83911f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x3 a1 = float4x3(-64.71405f, 295.066833f, 212.25708f, 349.6283f, 119.875916f, -37.8058167f, 142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f);
+            float4x3 b1 = float4x3(-435.62674f, 12.0955811f, 40.3787842f, 345.784851f, -433.471252f, -355.649963f, 4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f);
+            float4x3 r1 = float4x3(-64.71405f, 4.772888f, 10.3631592f, 3.84344482f, 119.875916f, -37.8058167f, 1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x3 a2 = float4x3(156.985718f, 507.6183f, 270.830444f, 337.7343f, 384.915833f, 432.5182f, 154.292725f, -37.0853271f, 7.76147461f, 238.094727f, 12.8520508f, -100.240662f);
+            float4x3 b2 = float4x3(-131.4183f, -473.9876f, 76.2178345f, 92.2102051f, -368.189575f, -77.46716f, 135.230591f, 274.277283f, 132.180237f, -179.877319f, 51.9685669f, 367.214233f);
+            float4x3 r2 = float4x3(25.5674133f, 33.6306763f, 42.17694f, 61.1037f, 16.7262573f, 45.182373f, 19.0621338f, -37.0853271f, 7.76147461f, 58.2174072f, 12.8520508f, -100.240662f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x3 a3 = float4x3(34.552002f, -251.189758f, -238.372253f, 511.514648f, 288.433533f, 367.109863f, 44.760437f, -437.0456f, -259.2056f, -228.565826f, 83.49725f, 424.367065f);
+            float4x3 b3 = float4x3(-395.2128f, 270.485229f, -73.104126f, 89.3499756f, -288.308533f, -168.324646f, 311.6159f, -468.341949f, 381.983948f, -1.39886475f, -102.288605f, -87.4248657f);
+            float4x3 r3 = float4x3(34.552002f, -251.189758f, -19.0598755f, 64.76477f, 0.125f, 30.4605713f, 44.760437f, -437.0456f, -259.2056f, -0.5508728f, 83.49725f, 74.6676f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mod_wide_scalar()
+        {
+            float4x3 a0 = float4x3(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f, -450.807678f, 186.094788f, -84.47363f, -318.7815f, 433.4547f, -54.60019f);
+            float b0 = (-90.49924f);
+            float4x3 r0 = float4x3(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f, -88.81073f, 5.09631348f, -84.47363f, -47.283783f, 71.45776f, -54.60019f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x3 a1 = float4x3(-172.338867f, 222.361877f, 5.79638672f, 254.5108f, -433.0937f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 483.5506f);
+            float b1 = (-429.714661f);
+            float4x3 r1 = float4x3(-172.338867f, 222.361877f, 5.79638672f, 254.5108f, -3.37902832f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 53.8359375f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x3 a2 = float4x3(-331.993347f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 405.773621f, -194.761444f, 235.724f, 465.984863f, -304.153168f, -295.520264f, 313.7224f);
+            float b2 = (336f);
+            float4x3 r2 = float4x3(-331.993347f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 69.77362f, -194.761444f, 235.724f, 129.984863f, -304.153168f, -295.520264f, 313.7224f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x3 a3 = float4x3(-232.202637f, 244.096619f, 162.524231f, 390.016174f, 90.00452f, 155.933533f, 217.3377f, -306.819275f, 149.09375f, 503.828369f, -194.130127f, 214.863037f);
+            float b3 = (191.619751f);
+            float4x3 r3 = float4x3(-40.5828857f, 52.4768677f, 162.524231f, 6.77667236f, 90.00452f, 155.933533f, 25.7179565f, -115.199524f, 149.09375f, 120.588867f, -2.510376f, 23.2432861f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float4x3 b0 = float4x3(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f, 397.0448f, -393.890656f, -372.067078f, 201.012268f, -95.566864f, -258.951477f);
+            float4x3 r0 = float4x3(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f, -396.4224f, -2.53173828f, -24.3553162f, -195.410126f, -14.1549377f, -137.470917f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (106.983582f);
+            float4x3 b1 = float4x3(469.323547f, -34.80899f, 184.836548f, 374.79425f, -131.872711f, -120.092865f, 4.506653f, -111.401947f, 391.54248f, -218.668884f, 196.377441f, -511.032623f);
+            float4x3 r1 = float4x3(106.983582f, 2.55661f, 106.983582f, 106.983582f, 106.983582f, 106.983582f, 3.33056641f, 106.983582f, 106.983582f, 106.983582f, 106.983582f, 106.983582f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (499.9535f);
+            float4x3 b2 = float4x3(-433.523071f, -163.866852f, 177.004028f, 110.650146f, 17.68457f, -95.85297f, -432.440979f, 192.692078f, -268.131775f, 271.075134f, 423.7027f, -413.233246f);
+            float4x3 r2 = float4x3(66.43042f, 8.352936f, 145.945435f, 57.3529053f, 4.78552246f, 20.68866f, 67.51251f, 114.569336f, 231.821716f, 228.878357f, 76.25079f, 86.7202454f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (127.956238f);
+            float4x3 b3 = float4x3(-298.204681f, -352.4181f, -175.607727f, -152.899292f, 34.6194458f, -380.802948f, 0.352050781f, 485.900879f, 266.150818f, 483.82074f, 11.777832f, 274.135864f);
+            float4x3 r3 = float4x3(127.956238f, 127.956238f, 127.956238f, 127.956238f, 24.0979f, 127.956238f, 0.1618042f, 127.956238f, 127.956238f, 127.956238f, 10.1779175f, 127.956238f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_plus()
+        {
+            float4x3 a0 = float4x3(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f);
+            float4x3 r0 = float4x3(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float4x3 a1 = float4x3(377.230164f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f);
+            float4x3 r1 = float4x3(377.230164f, 34.28363f, 258.330383f, 465.355957f, 309.59314f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float4x3 a2 = float4x3(-364.802551f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f);
+            float4x3 r2 = float4x3(-364.802551f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f, -116.536224f, -496.053284f, -330.005341f, -379.674255f, -339.673218f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float4x3 a3 = float4x3(-29.0835266f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f, 87.64923f);
+            float4x3 r3 = float4x3(-29.0835266f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f, 87.64923f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_neg()
+        {
+            float4x3 a0 = float4x3(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f, -495.837952f, -270.859467f, 19.68689f, 268.2367f, -180.600525f, 223.381287f);
+            float4x3 r0 = float4x3(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f, 495.837952f, 270.859467f, -19.68689f, -268.2367f, 180.600525f, -223.381287f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float4x3 a1 = float4x3(-410.392059f, -349.149475f, -110.9393f, -238.2196f, 292.543518f, 469.2926f, 48.29071f, 88.7237549f, 66.1485f, 55.7080078f, 464.541382f, 499.2428f);
+            float4x3 r1 = float4x3(410.392059f, 349.149475f, 110.9393f, 238.2196f, -292.543518f, -469.2926f, -48.29071f, -88.7237549f, -66.1485f, -55.7080078f, -464.541382f, -499.2428f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float4x3 a2 = float4x3(175.015015f, -306.1656f, 149.660034f, 320.391724f, -359.8338f, 22.0384521f, -159.55426f, 419.822449f, 303.323425f, 363.716736f, 280.887878f, -270.6513f);
+            float4x3 r2 = float4x3(-175.015015f, 306.1656f, -149.660034f, -320.391724f, 359.8338f, -22.0384521f, 159.55426f, -419.822449f, -303.323425f, -363.716736f, -280.887878f, 270.6513f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float4x3 a3 = float4x3(-201.615753f, 95.48926f, 191.070251f, 371.973572f, 296.512573f, -164.169922f, -347.4581f, -237.404968f, -228.701965f, 61.0822754f, 128.331543f, 331.2558f);
+            float4x3 r3 = float4x3(201.615753f, -95.48926f, -191.070251f, -371.973572f, -296.512573f, 164.169922f, 347.4581f, 237.404968f, 228.701965f, -61.0822754f, -128.331543f, -331.2558f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_prefix_inc()
+        {
+            float4x3 a0 = float4x3(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f, -323.614868f, -456.8903f, -76.50766f, -305.584778f, 64.0965f, 148.679321f);
+            float4x3 r0 = float4x3(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f, -322.614868f, -455.8903f, -75.50766f, -304.584778f, 65.0965f, 149.679321f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float4x3 a1 = float4x3(363.2849f, -326.8778f, -179.894653f, 339.8766f, -38.41043f, -153.373688f, 261.625549f, 155.030823f, -396.650238f, 301.3058f, -221.355408f, -429.698151f);
+            float4x3 r1 = float4x3(364.2849f, -325.8778f, -178.894653f, 340.8766f, -37.41043f, -152.373688f, 262.625549f, 156.030823f, -395.650238f, 302.3058f, -220.355408f, -428.698151f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float4x3 a2 = float4x3(-271.2893f, -377.5592f, 223.232422f, -71.076355f, -388.2279f, 131.283142f, 22.3049316f, -480.760468f, 200.951782f, 117.9541f, 139.525818f, 335.6897f);
+            float4x3 r2 = float4x3(-270.2893f, -376.5592f, 224.232422f, -70.076355f, -387.2279f, 132.283142f, 23.3049316f, -479.760468f, 201.951782f, 118.9541f, 140.525818f, 336.6897f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float4x3 a3 = float4x3(162.6615f, -254.7315f, -89.25604f, 314.36554f, 244.728149f, 34.01062f, -90.44528f, -472.63623f, -34.5667725f, -71.27185f, -396.4901f, -314.987457f);
+            float4x3 r3 = float4x3(163.6615f, -253.7315f, -88.25604f, 315.36554f, 245.728149f, 35.01062f, -89.44528f, -471.63623f, -33.5667725f, -70.27185f, -395.4901f, -313.987457f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_postfix_inc()
+        {
+            float4x3 a0 = float4x3(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f);
+            float4x3 r0 = float4x3(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float4x3 a1 = float4x3(159.861023f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f);
+            float4x3 r1 = float4x3(159.861023f, 241.4649f, 287.220459f, -170.104645f, -270.652466f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float4x3 a2 = float4x3(-341.498535f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f);
+            float4x3 r2 = float4x3(-341.498535f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f, 403.508728f, -111.279541f, 446.607666f, -12.35257f, -232.150116f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float4x3 a3 = float4x3(64.57703f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f, 439.3f);
+            float4x3 r3 = float4x3(64.57703f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f, 439.3f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_prefix_dec()
+        {
+            float4x3 a0 = float4x3(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f, 337.968933f, 246.088989f, 171.964539f, -227.44281f, 298.2848f, 326.5078f);
+            float4x3 r0 = float4x3(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f, 336.968933f, 245.088989f, 170.964539f, -228.44281f, 297.2848f, 325.5078f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float4x3 a1 = float4x3(400.7209f, -326.452972f, -24.5845032f, 112.796875f, -341.9763f, -503.27417f, -79.6352539f, -131.00415f, 147.893677f, -15.7086487f, 188.758423f, 307.791931f);
+            float4x3 r1 = float4x3(399.7209f, -327.452972f, -25.5845032f, 111.796875f, -342.9763f, -504.27417f, -80.6352539f, -132.00415f, 146.893677f, -16.7086487f, 187.758423f, 306.791931f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float4x3 a2 = float4x3(-406.667725f, -188.69223f, -505.2157f, -372.241943f, -4.031769f, 83.76776f, -30.6314087f, -436.906555f, -51.668396f, 345.021545f, 4.73535156f, -68.65332f);
+            float4x3 r2 = float4x3(-407.667725f, -189.69223f, -506.2157f, -373.241943f, -5.031769f, 82.76776f, -31.6314087f, -437.906555f, -52.668396f, 344.021545f, 3.73535156f, -69.65332f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float4x3 a3 = float4x3(481.4961f, -357.673279f, 153.329651f, -233.624329f, -35.23831f, 340.619629f, 259.928833f, 335.354919f, 85.36487f, -1.39398193f, -407.4104f, -145.793427f);
+            float4x3 r3 = float4x3(480.4961f, -358.673279f, 152.329651f, -234.624329f, -36.23831f, 339.619629f, 258.928833f, 334.354919f, 84.36487f, -2.393982f, -408.4104f, -146.793427f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x3_operator_postfix_dec()
+        {
+            float4x3 a0 = float4x3(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f);
+            float4x3 r0 = float4x3(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float4x3 a1 = float4x3(-261.0089f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f);
+            float4x3 r1 = float4x3(-261.0089f, -230.227783f, -483.066528f, 378.641235f, 487.344849f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float4x3 a2 = float4x3(379.156128f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f);
+            float4x3 r2 = float4x3(379.156128f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f, -313.4259f, 178.3125f, 176.78949f, -370.7863f, 64.90387f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float4x3 a3 = float4x3(449.637756f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f, -240.610687f);
+            float4x3 r3 = float4x3(449.637756f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f, -240.610687f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..60f175469eccffce54d9c38b93f82a3016845c19
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d5d74a51bcf6045408a569332921009f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..0429fa0fcdf1caff92289ae9702f1f8cf4a6c171
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs
@@ -0,0 +1,974 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestFloat4x4
+    {
+        [TestCompiler]
+        public static void float4x4_zero()
+        {
+            TestUtils.AreEqual(float4x4.zero.c0.x, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c0.y, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c0.z, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c0.w, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c1.x, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c1.y, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c1.z, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c1.w, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c2.x, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c2.y, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c2.z, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c2.w, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c3.x, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c3.y, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c3.z, 0.0f);
+            TestUtils.AreEqual(float4x4.zero.c3.w, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_identity()
+        {
+            TestUtils.AreEqual(float4x4.identity.c0.x, 1.0f);
+            TestUtils.AreEqual(float4x4.identity.c0.y, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c0.z, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c0.w, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c1.x, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c1.y, 1.0f);
+            TestUtils.AreEqual(float4x4.identity.c1.z, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c1.w, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c2.x, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c2.y, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c2.z, 1.0f);
+            TestUtils.AreEqual(float4x4.identity.c2.w, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c3.x, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c3.y, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c3.z, 0.0f);
+            TestUtils.AreEqual(float4x4.identity.c3.w, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_equal_wide_wide()
+        {
+            float4x4 a0 = float4x4(-135.18924f, -49.0941162f, 169.129822f, 240.8053f, 314.7392f, 442.393f, 177.924438f, 335.5334f, 168.15448f, 350.729553f, 367.178467f, 46.9414673f, 188.76416f, -97.2113953f, -293.320984f, -234.822937f);
+            float4x4 b0 = float4x4(-220.014648f, 66.98004f, 499.2016f, -371.1131f, 208.448669f, 390.8037f, -72.44382f, 362.97644f, 194.678345f, 471.644836f, -404.044678f, -144.696747f, -494.446655f, -252.970367f, 234.417114f, 398.724f);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x4 a1 = float4x4(417.0337f, 26.3864136f, 269.245728f, 29.4741821f, 479.485229f, -237.230957f, -221.9837f, -506.672546f, -22.98944f, 487.260864f, -419.731964f, 337.2033f, 245.043884f, 390.215881f, 84.4129639f, 434.2079f);
+            float4x4 b1 = float4x4(260.4287f, 370.144226f, 89.579834f, -434.816833f, -109.845337f, 336.973022f, -409.154968f, 500.387573f, -174.081818f, 395.101135f, 350.3393f, -243.144592f, -416.397369f, 151.576477f, -18.2243347f, -431.677917f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x4 a2 = float4x4(-68.7284241f, 485.769958f, 413.169739f, -418.2693f, -346.795868f, 504.159668f, 345.186279f, -434.713043f, -499.7741f, 282.019043f, 259.15625f, 306.455933f, 435.2254f, -386.8997f, 211.364014f, -7.229828f);
+            float4x4 b2 = float4x4(-468.330963f, 429.495728f, 477.389221f, -433.4254f, 273.5464f, -34.9762268f, 221.968445f, 85.91913f, -85.59894f, 392.7608f, -117.924072f, -445.3056f, -242.468964f, 173.643066f, 389.897766f, -14.2904663f);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x4 a3 = float4x4(-32.0532227f, -106.298553f, -382.924957f, -424.7822f, -267.8125f, 229.897034f, 358.1797f, -76.33087f, -493.684326f, 139.350586f, 211.756653f, -178.8342f, -262.786865f, 506.270325f, 352.288879f, -132.7894f);
+            float4x4 b3 = float4x4(-317.55304f, -265.652771f, -424.168274f, 11.6213379f, 408.686218f, -181.278351f, -139.8205f, -488.924561f, -207.703278f, -341.9881f, -470.552917f, -462.804352f, 419.075562f, 143.638733f, -79.912384f, -224.6936f);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_equal_wide_scalar()
+        {
+            float4x4 a0 = float4x4(65.6712f, 404.415527f, -269.730164f, 83.6306152f, 152.9945f, -155.868286f, 314.671265f, 386.365173f, 290.04895f, -132.6352f, -65.66748f, -69.68326f, -191.190765f, 186.845215f, -232.895691f, -319.144043f);
+            float b0 = (-155.815765f);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float4x4 a1 = float4x4(-49.70108f, 333.396851f, 386.3775f, -296.7019f, -309.1172f, 141.542358f, -227.323334f, 83.87286f, -410.91687f, 110.501282f, -390.103577f, 36.57434f, -427.541443f, -268.170837f, 175.8117f, -193.47995f);
+            float b1 = (-300.8819f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float4x4 a2 = float4x4(291.051941f, -429.8739f, -275.156952f, -56.3323669f, -95.83597f, -124.865326f, 253.006165f, -300.509521f, 314.866516f, 195.616211f, -26.1289063f, -284.7747f, -242.672058f, 140.3606f, 505.644348f, 506.537964f);
+            float b2 = (423.97168f);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float4x4 a3 = float4x4(-502.3698f, 87.36731f, -433.136383f, -149.626923f, -358.698547f, -249.126862f, 469.5932f, 511.757751f, 51.911377f, 245.630432f, 192.774841f, -162.209167f, 205.5904f, -376.464355f, 270.5208f, -388.2033f);
+            float b3 = (-249.517639f);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_equal_scalar_wide()
+        {
+            float a0 = (36.38391f);
+            float4x4 b0 = float4x4(-400.4892f, -71.2868347f, 156.978088f, -225.238739f, 499.141785f, -211.979919f, 428.311951f, -489.501343f, -5.691559f, -30.8659363f, -362.9831f, 184.503174f, -160.470612f, 316.668823f, 390.369263f, 505.1051f);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            float a1 = (-294.6487f);
+            float4x4 b1 = float4x4(443.1991f, 96.5592651f, -257.012939f, -245.054962f, 326.464844f, -23.9599f, -168.694885f, 386.2486f, -227.090637f, -336.612427f, 365.108154f, -405.390839f, -473.995483f, 298.435364f, -149.86322f, 450.0664f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            float a2 = (153.47644f);
+            float4x4 b2 = float4x4(56.28778f, 39.3421021f, -350.403717f, -482.717224f, 239.9654f, -3.40603638f, -1.49484253f, 105.960449f, 151.537537f, 63.2832031f, -289.693176f, 137.553772f, -247.666473f, -339.420563f, 23.2382813f, 21.1778564f);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            float a3 = (477.03656f);
+            float4x4 b3 = float4x4(-411.318146f, 122.397095f, -401.49884f, -230.5611f, -214.954041f, 464.6731f, -186.327f, -99.4873352f, 214.232483f, -387.3675f, -448.7962f, 427.889526f, -43.6960449f, 182.698669f, 298.880127f, 246.436829f);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_not_equal_wide_wide()
+        {
+            float4x4 a0 = float4x4(279.994141f, -43.34201f, -465.724731f, 317.466553f, 85.7149658f, 360.8905f, 366.081543f, 154.542847f, 332.4262f, 397.11322f, -431.374969f, 489.0108f, 398.4336f, -489.817932f, 171.4049f, -67.82968f);
+            float4x4 b0 = float4x4(-460.9121f, -476.009033f, 468.1364f, -341.012543f, -62.65805f, -458.801666f, -457.730225f, -59.5232544f, 3.024231f, 155.812744f, -19.8399048f, -6.01693726f, -406.207916f, -102.420715f, -40.362915f, 452.6754f);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x4 a1 = float4x4(-192.278717f, 227.84082f, 62.1381836f, 262.186462f, -404.0531f, 34.449585f, -204.795776f, -285.4118f, -72.20682f, 444.749268f, 238.81781f, 365.1801f, -437.9229f, -362.442627f, 445.954346f, -0.417480469f);
+            float4x4 b1 = float4x4(93.25757f, -258.378052f, -184.0498f, -379.2353f, -370.687317f, -255.947235f, 29.0557861f, 322.407654f, 415.071716f, -467.726135f, -433.784668f, -212.165924f, 474.674927f, 452.483215f, -92.11273f, -385.9221f);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x4 a2 = float4x4(-506.828369f, 245.477051f, -173.571045f, 390.338562f, 252.837769f, 47.8658447f, 457.7105f, -313.22113f, 391.203857f, 481.786133f, 26.8878174f, -298.1424f, 240.077454f, -332.455139f, -333.607178f, -313.1897f);
+            float4x4 b2 = float4x4(420.2151f, -239.176056f, -99.0791f, 4.476013f, 264.348572f, 451.312317f, 232.958008f, -142.6222f, -300.2256f, 268.333252f, -112.103546f, -270.494019f, -71.9932251f, 99.46326f, 321.7033f, 200.059631f);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x4 a3 = float4x4(141.730164f, -261.118866f, 295.578735f, -16.0213013f, -487.266846f, -208.563873f, 30.3494873f, -157.876465f, 275.896057f, -450.7207f, -61.8988647f, 99.19006f, 206.357483f, 32.74652f, -278.623962f, -173.916809f);
+            float4x4 b3 = float4x4(-91.62833f, -113.010864f, 465.764221f, -485.127716f, -71.7267761f, 486.469238f, 425.8678f, -158.880951f, 292.179565f, 234.179932f, 243.249329f, 117.275146f, 3.97106934f, 410.42218f, -221.124725f, 443.13446f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_not_equal_wide_scalar()
+        {
+            float4x4 a0 = float4x4(-155.4411f, -19.4266052f, 174.633057f, 507.920715f, 59.177063f, 171.151489f, -58.92328f, -398.176849f, 492.20105f, -165.241516f, 270.341f, -380.243256f, 501.899048f, -134.345459f, 458.400452f, 46.7709961f);
+            float b0 = (-393.413544f);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float4x4 a1 = float4x4(161.459961f, -145.6124f, -0.449920654f, 350.461426f, 202.221008f, 242.664f, 382.677063f, -468.967957f, -497.459473f, -80.93225f, -328.587769f, -506.490326f, 449.348145f, 210.771f, 249.181824f, -338.468536f);
+            float b1 = (261.514221f);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float4x4 a2 = float4x4(229.670654f, 317.286072f, 401.939575f, 210.984863f, -147.096313f, -193.399048f, 207.731384f, 284.3921f, -509.0853f, 414.307617f, -52.2944641f, -140.437927f, -316.787781f, -358.696838f, 312.31897f, 270.629456f);
+            float b2 = (-76.5433044f);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float4x4 a3 = float4x4(-140.016724f, 113.137207f, 479.6996f, 6.097473f, -83.63458f, 249.909363f, 303.956f, 464.888672f, 44.6365356f, -259.91626f, -242.33551f, -403.686523f, -469.1471f, 135.987488f, -490.840759f, 470.225281f);
+            float b3 = (108.910645f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_not_equal_scalar_wide()
+        {
+            float a0 = (478.353149f);
+            float4x4 b0 = float4x4(459.553223f, 436.453247f, -488.714172f, 392.767944f, -266.736633f, 338.557861f, -338.100128f, -152.314545f, -452.820679f, 209.439331f, 50.10797f, 372.4344f, -488.0213f, 489.740784f, 270.4001f, -472.846771f);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            float a1 = (-286.850464f);
+            float4x4 b1 = float4x4(-384.691864f, 443.423523f, 358.7472f, -15.4140625f, -342.179169f, 468.967529f, -130.568085f, 401.785828f, -268.352264f, -239.231018f, 411.386536f, 139.769348f, 334.522034f, -223.629242f, -12.4884644f, 113.468872f);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            float a2 = (-189.652252f);
+            float4x4 b2 = float4x4(-212.846558f, 306.1256f, -178.330383f, 382.141968f, -340.8656f, -17.58023f, -409.874847f, -349.70166f, 275.8543f, -229.371948f, -127.505737f, 90.75342f, -422.087128f, -2.44754028f, -280.5517f, -484.374359f);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            float a3 = (-33.7634277f);
+            float4x4 b3 = float4x4(374.593872f, 437.092346f, 286.22583f, -18.2327881f, 289.732361f, 479.485718f, 153.853943f, 502.982117f, -510.3844f, 65.78888f, -237.4867f, 219.916138f, -275.342743f, -78.93146f, -449.403564f, -253.034515f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_wide_wide()
+        {
+            float4x4 a0 = float4x4(51.7102661f, -313.85556f, 283.047668f, 235.021912f, 44.07837f, -207.255676f, 3.38293457f, -144.301331f, -69.3696f, -135.667969f, -194.787354f, -33.473877f, -19.67508f, 423.237976f, -71.6983f, -501.886f);
+            float4x4 b0 = float4x4(-261.835236f, -19.81073f, -149.25882f, 205.99823f, -306.024384f, 102.121704f, 231.906311f, 179.49884f, 473.2249f, 15.8916626f, 270.049927f, 490.914f, -185.734131f, 76.4331055f, 97.75232f, 419.300781f);
+            bool4x4 r0 = bool4x4(false, true, false, false, false, true, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x4 a1 = float4x4(7.64386f, 302.262878f, -140.5505f, -436.5867f, -351.4417f, 364.970825f, 301.8941f, 407.550964f, 269.1078f, 462.98822f, 223.884155f, -287.18924f, 283.6386f, 511.864319f, -60.4967957f, -234.303467f);
+            float4x4 b1 = float4x4(73.953186f, 481.032349f, 7.00744629f, -7.32409668f, -413.075745f, -154.1189f, 449.202881f, 502.014282f, -382.315857f, 251.535156f, 143.17395f, 293.660339f, -292.769562f, -43.2182f, -353.4112f, 458.32605f);
+            bool4x4 r1 = bool4x4(true, true, true, true, false, false, true, true, false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x4 a2 = float4x4(-316.1384f, -417.522156f, 441.643433f, -191.950623f, 397.811584f, -144.666626f, 417.079041f, -322.980133f, -81.2850952f, 319.325317f, 146.764038f, -316.583374f, -150.857544f, -314.606323f, 7.14312744f, -458.8273f);
+            float4x4 b2 = float4x4(-114.556458f, 441.429749f, -113.333679f, 435.622925f, 383.656128f, -293.7116f, -391.35498f, 43.12201f, 433.223633f, -201.382446f, -241.421173f, 376.469849f, -503.39743f, -359.780945f, 118.631531f, -510.030518f);
+            bool4x4 r2 = bool4x4(true, true, false, true, false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x4 a3 = float4x4(333.227722f, -349.9805f, 354.725037f, -451.62915f, 321.634766f, 365.723572f, -224.1594f, 388.5813f, -481.789429f, -473.9331f, -160.736511f, -200.438019f, -309.973083f, 80.28729f, -310.727356f, -83.5202f);
+            float4x4 b3 = float4x4(418.644775f, -95.54941f, 478.121216f, -129.558563f, -484.634674f, 352.228027f, -505.477631f, 162.993591f, -43.25766f, 18.279541f, 479.078979f, 437.282776f, -281.992035f, 433.0409f, -344.169678f, -232.819916f);
+            bool4x4 r3 = bool4x4(true, true, true, true, false, false, false, false, true, true, true, true, true, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_wide_scalar()
+        {
+            float4x4 a0 = float4x4(-221.869781f, -121.546478f, -97.5239258f, 479.8811f, 67.11902f, 137.3288f, 282.9666f, 258.2791f, -111.413147f, -288.081116f, 82.6654053f, -361.6429f, -68.0881958f, 12.7880249f, -66.703064f, -78.76297f);
+            float b0 = (199.0675f);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, false, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float4x4 a1 = float4x4(25.7277222f, -330.442657f, -48.9205322f, 359.604431f, -8.150085f, 241.2768f, -183.437775f, 423.027161f, -334.622742f, -98.31558f, 300.410156f, 297.925232f, -492.108154f, -395.807251f, 95.78882f, -220.62146f);
+            float b1 = (101.37085f);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float4x4 a2 = float4x4(-455.37558f, -296.372131f, 272.488342f, 360.207947f, 389.727417f, 68.7366943f, -400.615234f, -85.46912f, -467.702148f, -51.38788f, 201.764648f, -47.8412781f, -180.740051f, -409.0157f, 229.699036f, 176.197876f);
+            float b2 = (360.291565f);
+            bool4x4 r2 = bool4x4(true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float4x4 a3 = float4x4(-410.45517f, -20.24649f, 150.797852f, -69.47418f, -304.7824f, 149.1767f, -426.086151f, -455.146057f, -110.2583f, -276.355621f, 494.5564f, 472.353882f, -131.305f, -404.2739f, 498.876648f, 370.978516f);
+            float b3 = (-264.4348f);
+            bool4x4 r3 = bool4x4(true, false, false, false, true, false, true, true, false, true, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_scalar_wide()
+        {
+            float a0 = (-250.484924f);
+            float4x4 b0 = float4x4(-377.196533f, -505.147552f, 375.9267f, 110.17395f, -118.097565f, -40.4508972f, -299.744324f, 31.4371338f, -458.904541f, 13.6846924f, -458.5069f, 248.276489f, 389.231445f, 488.745544f, -221.637878f, -424.2672f);
+            bool4x4 r0 = bool4x4(false, false, true, true, true, true, false, true, false, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            float a1 = (249.059021f);
+            float4x4 b1 = float4x4(-22.1361389f, -442.247742f, -340.857544f, -95.1117249f, 15.4094238f, 87.29248f, 495.067627f, 316.0185f, -125.568115f, 122.164795f, 96.75537f, -228.906342f, -143.9527f, -230.238281f, -327.6126f, 103.39801f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, true, true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            float a2 = (434.488831f);
+            float4x4 b2 = float4x4(-157.4502f, 190.572144f, 108.2583f, 132.550781f, -431.515228f, -192.203522f, -431.835f, -85.58124f, 328.670532f, 273.577881f, -178.669067f, 352.6363f, -82.6058044f, 238.908875f, 291.335327f, 183.357361f);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            float a3 = (-185.0326f);
+            float4x4 b3 = float4x4(-179.355042f, -331.5387f, 59.2844238f, 356.62677f, 119.394043f, -80.44003f, 392.85907f, 306.155457f, -504.529449f, 349.384338f, 115.500305f, -251.656525f, 197.048157f, -268.077026f, 381.1057f, -367.121582f);
+            bool4x4 r3 = bool4x4(true, false, true, true, true, true, true, true, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_wide_wide()
+        {
+            float4x4 a0 = float4x4(-229.29068f, 505.536621f, -73.80707f, 100.292053f, -419.214783f, -159.559753f, -396.770355f, 127.037415f, 489.1399f, 51.9188843f, 155.384766f, -135.631653f, -425.978149f, -228.430511f, 383.03833f, 136.533569f);
+            float4x4 b0 = float4x4(-445.845032f, -420.035278f, 299.0244f, -13.8809814f, 151.5617f, -163.50943f, -391.096039f, 479.283752f, -77.6748657f, -46.584198f, -415.377f, 71.46698f, -206.061035f, 360.8363f, 236.968811f, 14.550354f);
+            bool4x4 r0 = bool4x4(true, true, false, true, false, true, false, false, true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x4 a1 = float4x4(8.602417f, -251.324371f, -345.954926f, -170.565918f, -293.2544f, 139.125f, 214.3031f, 238.7699f, 105.535217f, -170.9253f, 26.9802246f, -188.928314f, 201.786621f, -506.057159f, 15.454895f, 115.080688f);
+            float4x4 b1 = float4x4(364.735168f, -159.06131f, 226.631165f, 182.796021f, 341.839355f, -79.13046f, -247.296814f, 164.589111f, -352.1598f, 9.822632f, 186.721619f, -325.913635f, -77.93036f, -379.746033f, 251.45575f, -144.183563f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, true, true, true, true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x4 a2 = float4x4(-496.971832f, 339.888123f, 372.228333f, 313.2387f, -419.108948f, -265.329773f, -42.5019836f, 369.163879f, 67.16907f, -256.6989f, -104.105927f, 499.570129f, 41.6635132f, 151.1521f, 220.688354f, -344.658875f);
+            float4x4 b2 = float4x4(337.8899f, -249.505554f, -225.9013f, -249.491272f, 381.122864f, 325.5454f, 455.49884f, 333.318665f, 118.980347f, 223.19812f, -385.289063f, 333.8808f, -437.4107f, 243.975464f, -302.8199f, -32.7101746f);
+            bool4x4 r2 = bool4x4(false, true, true, true, false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x4 a3 = float4x4(-285.2413f, -94.15863f, -75.18497f, 304.360779f, -153.398468f, -83.06839f, -59.9485779f, 228.588379f, 64.9057f, 65.0849f, -3.845337f, 471.922363f, 350.319824f, 220.831f, 134.9466f, 41.8203735f);
+            float4x4 b3 = float4x4(-228.691467f, 388.413147f, -23.7245483f, -180.5635f, -433.434021f, 157.857361f, -2.47369385f, 258.287842f, -327.375854f, 408.474548f, 403.882568f, 400.3172f, -505.992645f, 297.639038f, -442.736755f, 395.710938f);
+            bool4x4 r3 = bool4x4(false, false, false, true, true, false, false, false, true, false, false, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_wide_scalar()
+        {
+            float4x4 a0 = float4x4(11.156311f, -411.023224f, 385.885559f, -485.103058f, -491.180023f, 405.175354f, 173.575073f, 69.26929f, 501.306824f, -367.027771f, -86.12451f, -489.090576f, -172.518158f, -18.1496277f, -236.414948f, -238.8945f);
+            float b0 = (-302.816956f);
+            bool4x4 r0 = bool4x4(true, false, true, false, false, true, true, true, true, false, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float4x4 a1 = float4x4(-27.2391357f, 240.164551f, -481.4781f, 185.59436f, 33.29474f, -510.228149f, -183.2862f, -386.127655f, -13.6382141f, -7.34790039f, -261.865967f, 52.24951f, 16.3232422f, -410.5101f, -262.2675f, -458.255981f);
+            float b1 = (471.779358f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float4x4 a2 = float4x4(-218.866119f, 290.573059f, 180.2633f, -482.863953f, 100.7063f, 180.672546f, 501.319763f, -289.280975f, -25.8497f, 455.1624f, -63.3173523f, -17.4467773f, 53.01776f, 88.81958f, 182.357971f, -428.927216f);
+            float b2 = (-34.6923523f);
+            bool4x4 r2 = bool4x4(false, true, true, false, true, true, true, false, true, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float4x4 a3 = float4x4(408.336853f, 495.172668f, 345.030029f, 337.561951f, 175.888367f, -412.795074f, 57.1717529f, 413.0246f, 34.45819f, -99.4767761f, -76.55893f, -494.980225f, -27.0163879f, -468.51767f, -335.857025f, 481.1654f);
+            float b3 = (-460.198639f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_scalar_wide()
+        {
+            float a0 = (453.546082f);
+            float4x4 b0 = float4x4(-226.2044f, -423.465f, 409.405518f, 453.877075f, 87.47571f, 113.795593f, 176.409241f, -140.440033f, -182.48288f, -158.2933f, -162.685333f, -193.328674f, 230.181274f, -102.58783f, 392.520569f, -177.478668f);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            float a1 = (-10.2950134f);
+            float4x4 b1 = float4x4(-24.04895f, 172.448669f, 374.048035f, -368.99762f, -210.195282f, 149.470215f, -281.343262f, -100.469177f, 304.864441f, -361.524841f, -372.452362f, -33.9095459f, -69.5952759f, -460.4324f, -309.341675f, 486.131531f);
+            bool4x4 r1 = bool4x4(true, false, false, true, true, false, true, true, false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            float a2 = (471.920959f);
+            float4x4 b2 = float4x4(479.361572f, -107.004181f, 331.636536f, -340.840149f, -384.2146f, -451.726563f, 467.97876f, -236.569122f, 44.6547241f, -285.797852f, 42.730957f, 338.18512f, 274.017029f, -108.60437f, -211.37326f, -19.00415f);
+            bool4x4 r2 = bool4x4(false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            float a3 = (194.114685f);
+            float4x4 b3 = float4x4(395.7599f, -320.206238f, -384.86615f, 310.543762f, 495.990845f, -60.93524f, 178.748779f, 42.3462524f, 294.611267f, -36.6795654f, 36.8616333f, 405.469543f, 399.112427f, -209.86087f, -365.343658f, -167.460236f);
+            bool4x4 r3 = bool4x4(false, true, true, false, false, true, true, true, false, true, true, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_equal_wide_wide()
+        {
+            float4x4 a0 = float4x4(240.090515f, 462.213135f, 293.08252f, -427.870667f, -405.5227f, 204.591919f, 294.6701f, -327.564453f, -456.12326f, 282.30127f, 421.881165f, -311.71283f, 84.5675049f, 447.244629f, -154.494354f, -424.364746f);
+            float4x4 b0 = float4x4(-81.20383f, 493.637451f, -411.4721f, 99.16443f, -295.6677f, -480.462555f, 74.41406f, 260.916138f, 306.173279f, 139.564819f, -505.752472f, -489.6268f, -280.0326f, 303.1599f, 511.1902f, -104.659729f);
+            bool4x4 r0 = bool4x4(false, true, false, true, true, false, false, true, true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x4 a1 = float4x4(36.68451f, 267.0703f, 307.893921f, -351.760132f, -157.360352f, 152.709045f, 372.267151f, 202.368286f, -77.04346f, 438.1848f, 260.282349f, 386.034058f, -281.491f, -102.930054f, -346.716736f, -258.3412f);
+            float4x4 b1 = float4x4(95.14661f, -125.636353f, 376.2398f, -415.774719f, -47.48105f, 117.722107f, 469.378357f, -263.042358f, -216.002319f, 66.73425f, 99.21863f, 233.843018f, 439.839966f, 61.1151123f, -219.030579f, -404.7129f);
+            bool4x4 r1 = bool4x4(true, false, true, false, true, false, true, false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x4 a2 = float4x4(-383.302948f, -5.14703369f, 319.34375f, 465.022217f, 145.933472f, -215.074829f, -146.461517f, -349.893982f, 29.5991211f, -131.796631f, -438.9947f, 147.057922f, 221.112488f, -356.145355f, -32.83017f, 442.942017f);
+            float4x4 b2 = float4x4(-202.748352f, -312.476471f, 310.0719f, -320.363037f, 186.075989f, -42.6377869f, 82.56506f, 127.189087f, 198.286987f, -450.492035f, 20.901001f, 449.465881f, -478.7727f, 380.053955f, 99.1247559f, -450.329773f);
+            bool4x4 r2 = bool4x4(true, false, false, false, true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x4 a3 = float4x4(-301.139832f, -10.9749451f, -37.47458f, -70.38611f, -169.0245f, 432.800781f, -197.706573f, -131.6955f, 277.733948f, -480.483978f, 424.766052f, -477.7182f, 162.193726f, -21.5889587f, 154.217224f, 224.467163f);
+            float4x4 b3 = float4x4(45.421936f, 63.0155029f, 2.8447876f, 124.884644f, 246.547852f, -437.79364f, -83.328125f, 147.94397f, 281.880859f, -33.0036926f, -319.849152f, 107.796021f, 57.387085f, 286.116455f, -427.031738f, -465.191284f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, false, true, true, true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_equal_wide_scalar()
+        {
+            float4x4 a0 = float4x4(309.192444f, 69.67377f, -101.724182f, -315.9724f, -346.011047f, 424.15387f, -410.870056f, -483.902649f, 183.821167f, 320.4425f, -257.870056f, -386.801758f, -182.938812f, 349.250122f, 485.311584f, 373.5691f);
+            float b0 = (292.924255f);
+            bool4x4 r0 = bool4x4(false, true, true, true, true, false, true, true, true, false, true, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float4x4 a1 = float4x4(259.1515f, -128.525543f, -43.8748779f, 457.385742f, -77.6383057f, 479.451843f, -499.516449f, -398.132935f, 402.484863f, 87.91608f, -502.1736f, 125.950806f, -54.49362f, 250.667419f, 97.94293f, 228.021545f);
+            float b1 = (450.130066f);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float4x4 a2 = float4x4(-213.378662f, -24.8275757f, -451.0416f, 429.577576f, -308.4343f, 355.160339f, -279.4071f, 181.672241f, -290.148743f, -184.844086f, 447.6939f, 168.8866f, 26.3789673f, 392.558533f, 255.604858f, 162.163452f);
+            float b2 = (42.2608032f);
+            bool4x4 r2 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float4x4 a3 = float4x4(195.496277f, 357.5598f, 145.561829f, 363.8067f, -141.437439f, 102.221924f, -114.207733f, -429.839478f, -236.495941f, -175.762238f, -420.696442f, -97.8534546f, -273.685242f, -442.2249f, 156.187012f, -102.823273f);
+            float b3 = (463.248779f);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_less_equal_scalar_wide()
+        {
+            float a0 = (-511.152374f);
+            float4x4 b0 = float4x4(51.1589966f, 340.443665f, 312.81427f, 354.1925f, 136.396729f, -94.76788f, 288.5443f, 304.042847f, -148.618073f, -506.3001f, 27.5812378f, 48.47113f, 104.883484f, -488.685852f, -480.435181f, 421.936646f);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            float a1 = (239.721069f);
+            float4x4 b1 = float4x4(-101.018433f, -283.951477f, -55.24353f, -455.80484f, 131.107239f, -461.6988f, -388.482849f, -258.936035f, -225.223541f, -116.019989f, -442.595245f, 297.333374f, 36.6872559f, 485.097839f, 344.445679f, 237.592163f);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, true, false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            float a2 = (230.390869f);
+            float4x4 b2 = float4x4(-413.9848f, -215.901672f, 39.5603638f, 22.947998f, -162.060577f, 236.7337f, -253.951965f, -204.719086f, -161.616547f, -64.3859253f, -229.815643f, -484.825653f, -135.040436f, 351.694763f, 111.825378f, -249.982544f);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, true, false, false, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            float a3 = (435.8073f);
+            float4x4 b3 = float4x4(2.89263916f, -338.669983f, 381.346619f, 456.652466f, 432.051819f, 290.142456f, 189.297119f, 101.1286f, -150.379761f, -490.7479f, 219.139587f, -505.290527f, 326.6947f, -479.397919f, 195.13562f, 322.878967f);
+            bool4x4 r3 = bool4x4(false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_equal_wide_wide()
+        {
+            float4x4 a0 = float4x4(-386.5918f, -157.120789f, 391.015259f, -511.886871f, -5.42202759f, 287.645264f, -122.535187f, 7.48144531f, 152.946411f, 48.9862061f, 57.3381348f, 300.4649f, 349.25708f, 85.7496948f, -230.953308f, 418.711243f);
+            float4x4 b0 = float4x4(153.443f, 49.8924561f, 78.02582f, 138.813721f, -225.51059f, -339.3561f, -373.302063f, 364.9359f, -322.7154f, 125.47821f, -25.77658f, 297.518921f, 73.22235f, 462.783752f, 393.191345f, -95.0014343f);
+            bool4x4 r0 = bool4x4(false, false, true, false, true, true, true, false, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x4 a1 = float4x4(-131.039917f, -126.512207f, -156.818481f, 422.3775f, -413.089325f, 219.442749f, 35.5911255f, 447.181519f, -223.492981f, 302.123f, 459.852722f, -347.128021f, 364.9781f, 212.635437f, 504.276062f, -142.232971f);
+            float4x4 b1 = float4x4(381.357056f, 93.03192f, 254.253235f, 90.67279f, 348.938171f, 161.337646f, 79.43561f, 420.243469f, 453.684875f, -154.011658f, -97.29007f, 151.184753f, 57.36029f, -194.207092f, -462.670624f, 113.3866f);
+            bool4x4 r1 = bool4x4(false, false, false, true, false, true, false, true, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x4 a2 = float4x4(-132.2218f, 303.683777f, 265.210144f, 9.754395f, -233.0929f, 26.5675049f, 266.7807f, -250.072235f, 138.040833f, 174.276733f, -420.931641f, -42.8541565f, 216.485046f, 240.053833f, -470.382172f, 98.39673f);
+            float4x4 b2 = float4x4(-129.3533f, 8.107788f, 426.449524f, 410.693176f, 470.313416f, 220.399963f, -372.872681f, -242.178558f, 177.506226f, -172.638153f, 60.72284f, 478.250183f, 234.30304f, 297.821228f, 104.584595f, -462.418732f);
+            bool4x4 r2 = bool4x4(false, true, false, false, false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x4 a3 = float4x4(-20.8288574f, -218.440582f, 287.751831f, -356.966675f, -68.06952f, -432.918762f, 388.1424f, 396.4041f, -204.567474f, 179.752075f, -124.947357f, 22.3182373f, 425.500854f, 303.622742f, -325.6043f, 369.075317f);
+            float4x4 b3 = float4x4(-405.943878f, -347.055573f, -72.92624f, -137.9425f, 403.4298f, 501.5393f, -55.5280151f, 225.850769f, -57.1860046f, -185.230133f, -481.5948f, 319.055359f, 337.433655f, -481.092865f, 223.933167f, 174.322571f);
+            bool4x4 r3 = bool4x4(true, true, true, false, false, false, true, true, false, true, true, false, true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_equal_wide_scalar()
+        {
+            float4x4 a0 = float4x4(495.4574f, -14.3451233f, -463.4748f, 217.517517f, -246.865723f, -377.6587f, 53.8151245f, -123.332947f, -221.505463f, 252.994324f, -116.440369f, -395.3633f, 164.772583f, -287.007324f, 355.837036f, 184.195557f);
+            float b0 = (189.205139f);
+            bool4x4 r0 = bool4x4(true, false, false, true, false, false, false, false, false, true, false, false, false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float4x4 a1 = float4x4(273.012268f, 249.3841f, 396.392151f, 332.6654f, 243.761414f, -335.12146f, -302.0869f, 254.442261f, 179.005066f, 71.1767f, -331.271667f, 307.890564f, -388.578522f, 150.605774f, -219.892578f, -491.681f);
+            float b1 = (-418.1424f);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float4x4 a2 = float4x4(30.99707f, -74.50003f, -343.386475f, 216.031555f, -420.403137f, -78.38403f, -336.6411f, 317.0946f, -262.424927f, -228.411255f, 123.465454f, 264.102478f, 223.623352f, 440.5354f, -420.727f, 74.8443f);
+            float b2 = (199.232239f);
+            bool4x4 r2 = bool4x4(false, false, false, true, false, false, false, true, false, false, false, true, true, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float4x4 a3 = float4x4(-177.077881f, -28.5963745f, 165.287537f, -349.208f, 457.443726f, -191.223633f, 350.612122f, 475.075256f, 86.12921f, 63.16461f, -126.913239f, 80.77649f, -344.926941f, -409.61142f, -408.5478f, -415.6823f);
+            float b3 = (482.7102f);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_greater_equal_scalar_wide()
+        {
+            float a0 = (215.435364f);
+            float4x4 b0 = float4x4(204.802979f, -101.104034f, -122.055023f, -70.45615f, -239.62027f, -185.992737f, -455.612579f, 276.665833f, 79.39917f, 416.420532f, 379.2735f, -439.5147f, 67.14099f, -74.56064f, -367.256348f, 494.950745f);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, false, true, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            float a1 = (-61.2355347f);
+            float4x4 b1 = float4x4(-429.170258f, -213.824677f, -264.310181f, 243.11377f, -22.38388f, 304.862f, -323.686157f, 67.93805f, 125.303589f, -400.47052f, -283.159637f, -42.31961f, -429.510376f, 499.395874f, -289.963074f, -136.008789f);
+            bool4x4 r1 = bool4x4(true, true, true, false, false, false, true, false, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            float a2 = (-351.125244f);
+            float4x4 b2 = float4x4(-381.8183f, 393.3009f, 18.02362f, -169.92392f, -285.884949f, 163.7511f, 191.855347f, 114.0155f, -395.98584f, 189.366577f, 176.19812f, 61.7138062f, 507.548462f, 224.043823f, -422.9937f, -127.054993f);
+            bool4x4 r2 = bool4x4(true, false, false, false, false, false, false, false, true, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            float a3 = (95.5286255f);
+            float4x4 b3 = float4x4(362.568176f, -501.040436f, 314.6682f, 484.321533f, -284.813171f, 106.034f, -310.3689f, 373.605835f, 147.076172f, -297.522217f, 339.547058f, -193.014587f, -3.09042358f, 429.024658f, 157.236572f, 208.49408f);
+            bool4x4 r3 = bool4x4(false, true, false, false, true, false, true, false, false, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_add_wide_wide()
+        {
+            float4x4 a0 = float4x4(465.148376f, 278.9107f, -277.5299f, -65.1972046f, -473.324371f, -4.69555664f, -470.536774f, -109.9501f, -178.701447f, -420.033783f, 290.711121f, -446.529633f, 491.066467f, -261.1173f, -298.4069f, 502.4286f);
+            float4x4 b0 = float4x4(483.9944f, -204.07666f, -365.673553f, -509.920868f, -270.6975f, 486.763977f, 267.49176f, 251.642517f, 244.495117f, -78.67575f, 352.2055f, 82.7791748f, 462.5473f, -405.492f, -428.498322f, -41.87259f);
+            float4x4 r0 = float4x4(949.142761f, 74.8340454f, -643.2035f, -575.118042f, -744.021851f, 482.06842f, -203.045013f, 141.692413f, 65.79367f, -498.709534f, 642.9166f, -363.750458f, 953.6138f, -666.6093f, -726.9052f, 460.556f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x4 a1 = float4x4(284.5943f, 401.128418f, -36.26349f, -102.949158f, 503.198181f, -384.4291f, -45.22821f, -198.67395f, -62.8800049f, -79.5522461f, 413.098267f, -100.877594f, 418.524f, -183.143127f, 407.443726f, 300.486023f);
+            float4x4 b1 = float4x4(-269.9275f, 75.20447f, -141.913391f, -222.186768f, 41.3057251f, 148.339478f, -177.233124f, -176.51889f, 492.692444f, 439.043823f, -511.742767f, -399.057129f, -315.868469f, -228.07724f, -171.7052f, 467.17395f);
+            float4x4 r1 = float4x4(14.6668091f, 476.3329f, -178.17688f, -325.135925f, 544.5039f, -236.08963f, -222.461334f, -375.192841f, 429.812439f, 359.491577f, -98.6445f, -499.934723f, 102.655518f, -411.220367f, 235.738525f, 767.66f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x4 a2 = float4x4(-261.126129f, -309.830353f, 378.363342f, -224.094f, -164.555725f, -69.87393f, 224.634644f, -383.9926f, 149.221252f, 169.388f, 163.053955f, 57.0291138f, 342.950073f, 168.680481f, -470.770264f, -117.630493f);
+            float4x4 b2 = float4x4(-474.822937f, 311.390747f, 326.8454f, 475.2119f, 314.152954f, -262.594635f, -82.86911f, 156.299561f, 427.40155f, -279.099365f, -448.615234f, 284.3371f, 288.1856f, -232.39505f, -386.871918f, 162.903381f);
+            float4x4 r2 = float4x4(-735.9491f, 1.56039429f, 705.20874f, 251.11792f, 149.597229f, -332.468567f, 141.765533f, -227.693054f, 576.6228f, -109.711365f, -285.561279f, 341.3662f, 631.1357f, -63.71457f, -857.6422f, 45.27289f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x4 a3 = float4x4(252.8197f, -102.534393f, -379.402771f, -42.8822021f, 204.786438f, 91.59955f, 70.1311646f, -111.691772f, -443.875854f, 134.701477f, 170.9068f, -207.879974f, -19.8520813f, 480.440674f, -353.835052f, 433.982178f);
+            float4x4 b3 = float4x4(-339.6031f, -82.40527f, 1.93530273f, 122.2746f, -42.76419f, -413.0547f, -350.282959f, -10.6069031f, 172.557312f, 492.042175f, 67.58539f, -324.510925f, -82.16745f, -421.822266f, -503.698944f, -289.683838f);
+            float4x4 r3 = float4x4(-86.78339f, -184.939667f, -377.467468f, 79.392395f, 162.022247f, -321.455139f, -280.1518f, -122.298676f, -271.318542f, 626.743652f, 238.492188f, -532.390869f, -102.019531f, 58.61841f, -857.534f, 144.29834f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_add_wide_scalar()
+        {
+            float4x4 a0 = float4x4(459.898315f, -447.663361f, -94.43863f, 126.429871f, -36.254364f, -349.6413f, -2.79125977f, -478.4148f, 443.115234f, 268.092224f, 41.3210449f, -471.256073f, -2.664978f, 78.98584f, 202.14801f, 311.725464f);
+            float b0 = (500.997253f);
+            float4x4 r0 = float4x4(960.895569f, 53.3338928f, 406.558624f, 627.4271f, 464.7429f, 151.355957f, 498.206f, 22.5824585f, 944.1125f, 769.0895f, 542.3183f, 29.74118f, 498.332275f, 579.9831f, 703.145264f, 812.7227f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float4x4 a1 = float4x4(10.3458252f, 355.2328f, -197.800751f, 255.955261f, 244.1471f, -181.626556f, -2.45492554f, 300.900635f, -236.491943f, -160.5841f, -172.5422f, -242.9411f, 466.344116f, 237.987488f, 264.294f, 372.866821f);
+            float b1 = (-151.244446f);
+            float4x4 r1 = float4x4(-140.898621f, 203.988342f, -349.0452f, 104.710815f, 92.90265f, -332.871f, -153.699371f, 149.656189f, -387.7364f, -311.828552f, -323.786652f, -394.185547f, 315.09967f, 86.74304f, 113.049561f, 221.622375f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float4x4 a2 = float4x4(-198.837769f, 402.160339f, -117.024841f, 497.373779f, 485.9093f, -47.75714f, 77.81482f, -271.547974f, -133.2518f, 211.86676f, 253.1502f, -342.783173f, -185.248352f, -403.3855f, -358.848236f, 65.24756f);
+            float b2 = (-381.930969f);
+            float4x4 r2 = float4x4(-580.768738f, 20.22937f, -498.9558f, 115.44281f, 103.978333f, -429.6881f, -304.11615f, -653.478943f, -515.182739f, -170.064209f, -128.780762f, -724.7141f, -567.1793f, -785.316467f, -740.7792f, -316.6834f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float4x4 a3 = float4x4(127.201721f, 432.121155f, 436.088928f, -308.056946f, -255.149841f, 245.9632f, 420.0163f, 337.529236f, -311.7624f, 322.9428f, -342.249023f, 276.5263f, 488.771179f, -481.895233f, 289.026978f, -332.122925f);
+            float b3 = (-112.139862f);
+            float4x4 r3 = float4x4(15.0618591f, 319.9813f, 323.949066f, -420.1968f, -367.2897f, 133.823334f, 307.876434f, 225.389374f, -423.902252f, 210.802948f, -454.3889f, 164.386444f, 376.631317f, -594.0351f, 176.887115f, -444.2628f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_add_scalar_wide()
+        {
+            float a0 = (-325.512756f);
+            float4x4 b0 = float4x4(-264.088135f, -106.009247f, -355.4473f, -447.3303f, -158.7002f, -199.4837f, 180.318115f, 337.579346f, -37.0550232f, 230.805f, -140.174347f, 18.02417f, -138.614349f, 26.9041748f, -374.5376f, 154.46759f);
+            float4x4 r0 = float4x4(-589.6009f, -431.522f, -680.9601f, -772.843f, -484.212952f, -524.99646f, -145.194641f, 12.0665894f, -362.56778f, -94.70776f, -465.6871f, -307.4886f, -464.1271f, -298.608582f, -700.050354f, -171.045166f);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            float a1 = (268.38385f);
+            float4x4 b1 = float4x4(-190.963013f, 188.617249f, -504.916138f, 20.45404f, 197.945374f, 251.411926f, -421.0904f, 111.445374f, -73.26889f, 480.884583f, 438.05304f, 66.8443f, -270.796021f, -44.02191f, 197.6947f, 19.1139526f);
+            float4x4 r1 = float4x4(77.42084f, 457.0011f, -236.532288f, 288.8379f, 466.329224f, 519.7958f, -152.706543f, 379.829224f, 195.11496f, 749.268433f, 706.4369f, 335.228149f, -2.41217041f, 224.361938f, 466.078552f, 287.4978f);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            float a2 = (349.2378f);
+            float4x4 b2 = float4x4(366.2345f, -413.4803f, -260.720184f, 77.54236f, 183.9549f, -51.4989929f, -472.497467f, 107.126892f, 349.0772f, 431.595947f, -314.110962f, 396.996643f, -167.308624f, -157.114532f, 287.7625f, -367.33905f);
+            float4x4 r2 = float4x4(715.4723f, -64.24249f, 88.51761f, 426.780151f, 533.1927f, 297.7388f, -123.259674f, 456.3647f, 698.315f, 780.83374f, 35.12683f, 746.234436f, 181.929169f, 192.12326f, 637.0003f, -18.1012573f);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            float a3 = (96.23682f);
+            float4x4 b3 = float4x4(212.023132f, -400.693481f, 26.3428345f, 166.0332f, 49.9665527f, 154.5788f, -446.356934f, -46.7756958f, 426.568665f, -168.368256f, 254.265076f, -241.264923f, -278.259033f, -237.1731f, 174.13092f, 510.910278f);
+            float4x4 r3 = float4x4(308.259949f, -304.456665f, 122.579651f, 262.27002f, 146.203369f, 250.815613f, -350.120117f, 49.46112f, 522.8055f, -72.13144f, 350.5019f, -145.0281f, -182.022217f, -140.936279f, 270.367737f, 607.1471f);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_sub_wide_wide()
+        {
+            float4x4 a0 = float4x4(133.371033f, -131.832123f, -197.293152f, -485.28656f, -337.550323f, 471.6671f, 146.506592f, -130.585052f, 110.7771f, -235.5416f, 78.87933f, -347.686157f, -470.820557f, -11.45929f, -167.9479f, 330.676758f);
+            float4x4 b0 = float4x4(123.460266f, 359.56012f, -48.2484741f, 478.979065f, 207.158325f, 142.36731f, -125.6055f, -65.29901f, -477.876434f, 164.5f, 428.009583f, 72.62781f, -446.8805f, 432.091431f, -225.554657f, -112.451965f);
+            float4x4 r0 = float4x4(9.910767f, -491.392242f, -149.044678f, -964.2656f, -544.7086f, 329.2998f, 272.1121f, -65.28604f, 588.653564f, -400.0416f, -349.130249f, -420.313965f, -23.9400635f, -443.55072f, 57.60675f, 443.128723f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x4 a1 = float4x4(-508.350861f, -252.031891f, -427.9342f, 192.6576f, 168.429321f, 457.308777f, 470.058533f, -299.711884f, -308.939575f, 454.5334f, 26.1069336f, -482.711823f, -40.8535461f, 318.380676f, 475.210815f, 134.926941f);
+            float4x4 b1 = float4x4(-210.6128f, -172.925049f, -80.60748f, 270.046082f, -154.255585f, 148.475769f, 13.6611328f, 70.67108f, -221.325439f, -9.25882f, 288.173828f, 217.36145f, 307.540039f, -262.412659f, -405.378021f, 400.004333f);
+            float4x4 r1 = float4x4(-297.738068f, -79.10684f, -347.326721f, -77.38849f, 322.6849f, 308.833f, 456.3974f, -370.382965f, -87.6141357f, 463.7922f, -262.0669f, -700.073242f, -348.3936f, 580.793335f, 880.588867f, -265.0774f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x4 a2 = float4x4(388.481567f, 138.7182f, -385.5736f, -149.3648f, -158.534058f, 508.070679f, 482.7008f, 114.569275f, 364.83136f, 229.031f, -168.088074f, 373.4411f, -239.90097f, 379.928467f, 113.011841f, 306.835266f);
+            float4x4 b2 = float4x4(72.11908f, -154.880585f, -469.659973f, -320.615417f, 6.41229248f, -278.865051f, 15.8380737f, 27.51831f, 429.869629f, -458.622467f, -172.064423f, -284.524719f, 42.60669f, -223.474243f, -56.92975f, 61.807312f);
+            float4x4 r2 = float4x4(316.3625f, 293.5988f, 84.0863647f, 171.25061f, -164.94635f, 786.9357f, 466.862732f, 87.0509644f, -65.03827f, 687.653442f, 3.97634888f, 657.9658f, -282.50766f, 603.4027f, 169.941589f, 245.027954f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x4 a3 = float4x4(222.817444f, 271.9942f, 386.942932f, -55.75531f, 440.039368f, -362.724762f, 292.103149f, 246.660645f, -319.029236f, -115.244019f, -122.409058f, 56.0924072f, 210.677979f, -426.9796f, -337.58847f, 78.37268f);
+            float4x4 b3 = float4x4(-454.695526f, -114.060547f, 367.1687f, -351.2796f, 263.148865f, -492.305359f, 308.153259f, 455.3084f, -221.137665f, -466.658783f, 81.54944f, 48.54596f, -88.75711f, 83.8197f, -437.890564f, 410.3957f);
+            float4x4 r3 = float4x4(677.512939f, 386.054749f, 19.774231f, 295.5243f, 176.8905f, 129.5806f, -16.05011f, -208.647766f, -97.89157f, 351.414764f, -203.9585f, 7.54644775f, 299.4351f, -510.799316f, 100.302094f, -332.023f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_sub_wide_scalar()
+        {
+            float4x4 a0 = float4x4(48.9367065f, 410.4516f, -364.4417f, 163.980591f, -460.067322f, 110.919434f, 204.358337f, 180.269714f, -377.9257f, -470.262054f, 400.5349f, 461.507568f, -246.287262f, 21.6052856f, 246.350708f, -121.427368f);
+            float b0 = (-291.5904f);
+            float4x4 r0 = float4x4(340.5271f, 702.042f, -72.85132f, 455.570984f, -168.476929f, 402.509827f, 495.94873f, 471.8601f, -86.3353f, -178.671661f, 692.1253f, 753.097961f, 45.30313f, 313.195679f, 537.9411f, 170.163025f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float4x4 a1 = float4x4(-122.718414f, 360.15094f, 342.874573f, 18.92981f, 164.602356f, 97.0437f, 485.914978f, -205.75766f, 253.443237f, -121.163055f, 187.998413f, -450.820282f, -248.073364f, -26.9960632f, 441.5526f, 449.910583f);
+            float b1 = (-122.938721f);
+            float4x4 r1 = float4x4(0.2203064f, 483.089661f, 465.8133f, 141.86853f, 287.541077f, 219.982422f, 608.8537f, -82.81894f, 376.381958f, 1.77566528f, 310.937134f, -327.881561f, -125.134644f, 95.94266f, 564.491333f, 572.8493f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float4x4 a2 = float4x4(354.886047f, -189.193237f, 269.074829f, -59.11856f, 363.458374f, -73.7792053f, -46.1552124f, 109.913269f, 182.646912f, 229.015747f, -144.92868f, 469.2506f, -150.49231f, -192.3125f, -224.356842f, 285.876831f);
+            float b2 = (98.82147f);
+            float4x4 r2 = float4x4(256.064575f, -288.0147f, 170.253357f, -157.940033f, 264.6369f, -172.600677f, -144.976685f, 11.0917969f, 83.82544f, 130.194275f, -243.750153f, 370.429138f, -249.313782f, -291.133972f, -323.1783f, 187.055359f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float4x4 a3 = float4x4(-63.0108337f, 152.83313f, 92.32092f, -481.9931f, 55.80725f, -198.5921f, -338.3567f, -142.261749f, -201.510559f, -279.917542f, -495.640045f, 119.089966f, 382.1477f, 68.73401f, 470.9823f, -500.403046f);
+            float b3 = (499.9112f);
+            float4x4 r3 = float4x4(-562.922f, -347.078064f, -407.590271f, -981.9043f, -444.103943f, -698.5033f, -838.2679f, -642.173f, -701.421753f, -779.828735f, -995.5513f, -380.821228f, -117.763489f, -431.1772f, -28.928894f, -1000.31421f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_sub_scalar_wide()
+        {
+            float a0 = (294.5865f);
+            float4x4 b0 = float4x4(452.352539f, 256.9898f, -275.159882f, -89.02753f, 488.2284f, -333.2173f, -64.233f, -66.04172f, 341.204956f, -385.775055f, 75.3947754f, 354.943726f, 169.131409f, 88.21661f, 1.73498535f, 122.538025f);
+            float4x4 r0 = float4x4(-157.766052f, 37.59668f, 569.746338f, 383.614f, -193.6419f, 627.8038f, 358.8195f, 360.6282f, -46.61847f, 680.3616f, 219.191711f, -60.35724f, 125.455078f, 206.369873f, 292.8515f, 172.048462f);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            float a1 = (-264.945f);
+            float4x4 b1 = float4x4(-50.83719f, -347.65033f, 4.06555176f, -79.09543f, 354.358337f, -292.4925f, -53.2089844f, -246.3476f, 299.203369f, 432.1847f, -163.88f, 176.742554f, -104.98584f, -445.797638f, -28.8731689f, -169.588226f);
+            float4x4 r1 = float4x4(-214.107819f, 82.70532f, -269.010559f, -185.849579f, -619.303345f, 27.5474854f, -211.736023f, -18.5974121f, -564.1484f, -697.1297f, -101.065f, -441.687561f, -159.959167f, 180.852631f, -236.071838f, -95.35678f);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            float a2 = (-270.359253f);
+            float4x4 b2 = float4x4(68.04761f, -65.53128f, 440.380371f, 427.360657f, -81.47296f, 41.7131958f, 175.8208f, -214.949158f, -163.446869f, -218.829132f, 389.116882f, -74.10977f, -448.137238f, -410.375f, 363.211f, -263.5354f);
+            float4x4 r2 = float4x4(-338.40686f, -204.827972f, -710.7396f, -697.7199f, -188.886292f, -312.072449f, -446.180054f, -55.4100952f, -106.912384f, -51.53012f, -659.476135f, -196.249481f, 177.777985f, 140.015747f, -633.570251f, -6.82385254f);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            float a3 = (473.546021f);
+            float4x4 b3 = float4x4(433.4333f, 241.469421f, -446.7562f, -138.318115f, -414.005829f, 37.4823f, 290.049072f, -354.679932f, -322.974976f, -253.401947f, -412.353f, 269.2157f, -65.8092346f, -451.977417f, -407.732117f, 12.5319214f);
+            float4x4 r3 = float4x4(40.1127319f, 232.0766f, 920.302246f, 611.864136f, 887.5519f, 436.063721f, 183.496948f, 828.225952f, 796.521f, 726.948f, 885.899048f, 204.330322f, 539.3552f, 925.523438f, 881.278137f, 461.0141f);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mul_wide_wide()
+        {
+            float4x4 a0 = float4x4(-394.780548f, -412.3722f, -25.8745728f, -241.045959f, -93.6759949f, 244.159973f, 494.688477f, 53.5379639f, -239.4964f, 236.675842f, -211.8562f, -216.654816f, 467.9583f, -178.021912f, -386.394257f, -422.4354f);
+            float4x4 b0 = float4x4(-149.763977f, -345.04538f, -284.334045f, 267.979248f, -326.6485f, -150.689667f, 207.732422f, 366.192871f, 358.880737f, 214.853577f, 253.422791f, -307.7138f, 184.47113f, 426.436462f, -144.281433f, 459.4796f);
+            float4x4 r0 = float4x4(59123.9063f, 142287.125f, 7357.022f, -64595.3164f, 30599.123f, -36792.3867f, 102762.836f, 19605.22f, -85950.64f, 50850.6523f, -53689.19f, 66667.68f, 86324.8f, -75915.03f, 55749.5156f, -194100.453f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x4 a1 = float4x4(464.589539f, -251.315674f, -104.97879f, -66.93417f, -39.829895f, 401.5656f, 434.146179f, -336.4542f, -83.11417f, 329.960266f, -316.972168f, 474.937927f, -445.109161f, -301.003723f, 405.687866f, 142.373474f);
+            float4x4 b1 = float4x4(-358.313354f, -201.3652f, 254.909973f, 168.520935f, 8.794556f, -194.846466f, -405.362671f, -180.732178f, -189.746918f, -35.5184631f, 120.31665f, -136.203339f, 407.3416f, 301.6543f, -155.482391f, -461.394562f);
+            float4x4 r1 = float4x4(-166468.641f, 50606.23f, -26760.14f, -11279.81f, -350.286224f, -78243.64f, -175986.656f, 60808.0977f, 15770.6572f, -11719.6816f, -38137.03f, -64688.1328f, -181311.484f, -90799.07f, -63077.32f, -65690.34f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x4 a2 = float4x4(-416.213074f, -103.279205f, -52.9519043f, -40.82834f, -86.18509f, -257.316528f, 363.857239f, -229.860016f, 8.925293f, -2.44940186f, 37.7583f, 264.451782f, -321.251282f, -268.256042f, 43.9136963f, 274.833069f);
+            float4x4 b2 = float4x4(296.680359f, 341.001831f, -257.0968f, 17.5936279f, -443.845123f, 291.349243f, 490.19165f, 361.320984f, -509.289734f, 315.352661f, 125.083069f, -167.727112f, 396.8877f, -0.320404053f, 143.4115f, -396.3475f);
+            float4x4 r2 = float4x4(-123482.242f, -35218.4f, 13613.7656f, -718.3186f, 38252.832f, -74968.98f, 178359.781f, -83053.25f, -4545.56f, -772.4254f, 4722.92432f, -44355.7344f, -127500.68f, 85.950325f, 6297.729f, -108929.4f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x4 a3 = float4x4(378.421082f, -290.6334f, 209.916565f, 384.219727f, 363.081421f, -461.333374f, -134.366852f, 11.9394531f, 125.20166f, -219.271f, 358.96698f, 12.847168f, -479.7714f, 150.253113f, -500.840759f, 485.679932f);
+            float4x4 b3 = float4x4(350.960144f, -374.53418f, -165.456024f, -338.017334f, -199.633331f, -385.127f, -328.411316f, -423.3008f, -150.3247f, 402.9776f, 339.0208f, -29.2961426f, -447.5521f, 62.1604f, 471.492065f, 282.403381f);
+            float4x4 r3 = float4x4(132810.719f, 108852.141f, -34731.96f, -129872.93f, -72483.16f, 177671.938f, 44127.5938f, -5053.98f, -18820.9023f, -88361.3f, 121697.281f, -376.372467f, 214722.688f, 9339.794f, -236142.438f, 137157.656f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mul_wide_scalar()
+        {
+            float4x4 a0 = float4x4(328.203f, -290.10672f, 236.995728f, 120.481384f, 357.903137f, 134.867249f, -477.3105f, -438.272919f, -46.729187f, -238.405f, 422.08252f, -48.83484f, 355.30835f, 119.356628f, -196.995819f, 98.23602f);
+            float b0 = (192.211182f);
+            float4x4 r0 = float4x4(63084.2852f, -55761.7539f, 45553.23f, 23157.87f, 68792.9844f, 25922.9941f, -91744.4141f, -84240.95f, -8981.872f, -45824.1055f, 81128.98f, -9386.603f, 68294.2344f, 22941.6777f, -37864.8f, 18882.0625f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float4x4 a1 = float4x4(-325.552155f, -87.45099f, -130.474121f, -222.594574f, 126.015015f, 293.361084f, 174.381958f, -327.120056f, 56.62915f, 257.541565f, -475.6087f, -452.6919f, -49.22061f, 141.600952f, 431.5857f, 180.355164f);
+            float b1 = (53.9373169f);
+            float4x4 r1 = float4x4(-17559.41f, -4716.87158f, -7037.424f, -12006.1543f, 6796.91162f, 15823.1094f, 9405.695f, -17643.9785f, 3054.42432f, 13891.1006f, -25653.0566f, -24416.9863f, -2654.82764f, 7637.575f, 23278.5742f, 9727.874f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float4x4 a2 = float4x4(-40.9234619f, 120.014465f, -59.508667f, 319.489868f, -403.523163f, -408.1931f, -335.3932f, -364.242554f, 150.686157f, 391.87207f, 179.312439f, 354.5298f, 497.7614f, 418.436584f, -413.333374f, -329.520721f);
+            float b2 = (279.543518f);
+            float4x4 r2 = float4x4(-11439.8887f, 33549.2656f, -16635.2617f, 89311.32f, -112802.281f, -114107.742f, -93756.99f, -101821.648f, 42123.34f, 109545.3f, 50125.63f, 99106.5f, 139145.984f, 116971.234f, -115544.664f, -92115.38f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float4x4 a3 = float4x4(-322.703064f, -344.131165f, 209.612732f, 38.7976074f, -445.803833f, -71.467804f, -449.38623f, -64.39856f, -210.725952f, 389.325684f, 510.298218f, -497.581024f, -509.508575f, 131.99408f, 502.496826f, 282.81f);
+            float b3 = (-285.631226f);
+            float4x4 r3 = float4x4(92174.07f, 98294.61f, -59871.94f, -11081.8086f, 127335.492f, 20413.4355f, 128358.742f, 18394.24f, 60189.91f, -111203.57f, -145757.109f, 142124.672f, 145531.563f, -37701.63f, -143528.781f, -80779.37f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mul_scalar_wide()
+        {
+            float a0 = (-464.5347f);
+            float4x4 b0 = float4x4(329.360962f, -198.683441f, 184.0794f, 256.016174f, 266.226318f, -97.8947449f, 159.748108f, -351.8222f, 491.801575f, 49.90204f, 424.4626f, 160.1181f, -395.9921f, 125.20166f, -265.0158f, 314.656128f);
+            float4x4 r0 = float4x4(-152999.6f, 92295.35f, -85511.27f, -118928.4f, -123671.359f, 45475.5039f, -74208.54f, 163433.625f, -228458.891f, -23181.2285f, -197177.6f, -74380.4141f, 183952.063f, -58160.5156f, 123109.039f, -146168.688f);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            float a1 = (-292.712036f);
+            float4x4 b1 = float4x4(-37.72989f, 165.362244f, 356.517761f, -188.813324f, 504.9157f, 40.5721436f, -206.775116f, -61.60269f, 118.971619f, 53.7483521f, -198.6694f, 96.236084f, -20.2418823f, -31.1239624f, 38.89044f, -13.1333008f);
+            float4x4 r1 = float4x4(11043.9922f, -48403.52f, -104357.039f, 55267.9336f, -147794.9f, -11875.9551f, 60525.5664f, 18031.85f, -34824.4258f, -15732.79f, 58152.9258f, -28169.46f, 5925.04248f, 9110.358f, -11383.7f, 3844.27515f);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            float a2 = (507.871277f);
+            float4x4 b2 = float4x4(95.0179443f, 340.7486f, 438.986877f, -227.165955f, 452.573f, 144.014954f, -31.58603f, 42.29773f, -466.027161f, 287.453979f, 328.9969f, -164.243134f, -511.2683f, -9.594299f, 431.190125f, -132.141815f);
+            float4x4 r2 = float4x4(48256.8828f, 173056.422f, 222948.828f, -115371.063f, 229848.828f, 73141.0547f, -16041.6367f, 21481.8027f, -236681.813f, 145989.625f, 167088.063f, -83414.37f, -259658.484f, -4872.669f, 218989.078f, -67111.03f);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            float a3 = (-87.502655f);
+            float4x4 b3 = float4x4(384.618652f, 385.83905f, -384.623077f, 236.278625f, 336.4452f, 272.744446f, -121.145477f, -194.381134f, -364.7453f, 360.356934f, -153.582489f, 63.94165f, 0.04345703f, -430.974f, -126.427887f, -338.7486f);
+            float4x4 r3 = float4x4(-33655.1523f, -33761.94f, 33655.54f, -20675.0078f, -29439.8477f, -23865.8633f, 10600.5508f, 17008.8652f, 31916.1816f, -31532.1875f, 13438.876f, -5595.064f, -3.80260563f, 37711.37f, 11062.7754f, 29641.4023f);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_div_wide_wide()
+        {
+            float4x4 a0 = float4x4(246.265747f, -269.85614f, -451.619537f, -7.388489f, -308.205566f, -373.3948f, 360.41864f, 25.8097534f, -274.050476f, 127.538574f, -447.671753f, -137.458588f, -136.133179f, 12.4376221f, 228.513f, 356.972351f);
+            float4x4 b0 = float4x4(172.119812f, -77.14111f, -325.8354f, -450.608673f, -261.262146f, -122.449493f, -93.2107849f, -442.005219f, 484.362732f, -390.7818f, 402.02533f, 316.6507f, 397.154419f, -303.2622f, -118.591248f, -81.6503f);
+            float4x4 r0 = float4x4(1.43078089f, 3.49821424f, 1.38603592f, 0.0163966864f, 1.17967939f, 3.04937816f, -3.86670542f, -0.0583924167f, -0.565795958f, -0.326367736f, -1.11354113f, -0.434101641f, -0.3427714f, -0.0410127677f, -1.926896f, -4.37196636f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x4 a1 = float4x4(-24.7620544f, 411.6684f, -204.078888f, 11.3654175f, 82.15228f, 37.3894653f, 394.2658f, -429.912781f, 315.37384f, -122.665985f, 447.526123f, -210.4815f, -202.42157f, -453.007935f, 173.72699f, -167.121674f);
+            float4x4 b1 = float4x4(-84.34686f, -488.419434f, 404.160522f, -136.728851f, -19.8327026f, -102.607239f, 166.116028f, -112.840179f, -218.209686f, 458.517517f, 119.587219f, 356.240417f, -74.50687f, -336.773926f, -216.126312f, 322.385681f);
+            float4x4 r1 = float4x4(0.2935741f, -0.8428584f, -0.504945159f, -0.0831237659f, -4.14226341f, -0.364394039f, 2.37343621f, 3.80992651f, -1.44527888f, -0.267527372f, 3.742257f, -0.5908412f, 2.71681762f, 1.34513962f, -0.803821564f, -0.5183905f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x4 a2 = float4x4(-106.234528f, 414.312561f, 7.12084961f, 274.073669f, -39.0026855f, 39.065918f, -147.364166f, 434.3849f, 315.0672f, -106.636017f, -507.925262f, -17.1764526f, -385.865356f, 226.002136f, 345.168457f, 201.544189f);
+            float4x4 b2 = float4x4(220.2555f, -67.2345f, 2.229187f, -166.210968f, -247.732574f, 84.16095f, 477.148621f, 209.7508f, -386.7222f, -65.27734f, 410.454834f, 367.6507f, -456.572021f, 382.427979f, -163.860687f, -213.721375f);
+            float4x4 r2 = float4x4(-0.482324064f, -6.16220236f, 3.19437075f, -1.64895058f, 0.157438666f, 0.464181036f, -0.3088433f, 2.07095718f, -0.814712f, 1.6335839f, -1.23746932f, -0.0467194878f, 0.8451358f, 0.5909665f, -2.106475f, -0.9430231f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x4 a3 = float4x4(-364.71106f, -508.3727f, 263.803528f, 392.039f, 19.7166138f, -14.4797668f, -431.478668f, -8.395416f, 3.10827637f, -139.841125f, 402.5097f, 318.3109f, -274.568054f, -193.369141f, 288.227f, 0.620605469f);
+            float4x4 b3 = float4x4(227.003845f, -337.9897f, 149.321716f, -198.855316f, -468.455017f, 183.258728f, 217.357544f, -167.570221f, -150.7587f, 48.44922f, 410.15564f, -4.68936157f, -465.338165f, -48.30713f, 403.645752f, -387.142f);
+            float4x4 r3 = float4x4(-1.60662949f, 1.50410724f, 1.76667893f, -1.97147858f, -0.0420885943f, -0.0790127f, -1.98511016f, 0.0501008853f, -0.02061756f, -2.88634419f, 0.981358469f, -67.87937f, 0.590039849f, 4.002911f, 0.7140593f, -0.00160304352f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_div_wide_scalar()
+        {
+            float4x4 a0 = float4x4(-244.517456f, 69.1123047f, -333.023132f, 257.396851f, 403.2456f, 154.34436f, 131.526611f, -261.8864f, -348.9238f, -275.5387f, 210.557922f, 287.6424f, 504.372253f, 491.7871f, -26.6315918f, -253.236664f);
+            float b0 = (-60.0243835f);
+            float4x4 r0 = float4x4(4.07363558f, -1.15140378f, 5.548131f, -4.28820467f, -6.71803f, -2.571361f, -2.19121981f, 4.36300039f, 5.813034f, 4.590446f, -3.507873f, -4.79209232f, -8.402789f, -8.193122f, 0.443679541f, 4.21889639f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float4x4 a1 = float4x4(272.895142f, -460.87558f, -502.646027f, -84.3248f, -174.690338f, 83.7963257f, 197.042053f, 317.168274f, 403.387146f, 81.6464844f, 60.6068726f, -413.5605f, 207.341f, 358.562134f, 20.7490845f, -68.57712f);
+            float b1 = (178.096191f);
+            float4x4 r1 = float4x4(1.5322907f, -2.58779025f, -2.82232881f, -0.473478943f, -0.9808763f, 0.470511615f, 1.10638f, 1.78088188f, 2.26499581f, 0.458440363f, 0.340304136f, -2.32211876f, 1.16420794f, 2.013306f, 0.11650493f, -0.3850566f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float4x4 a2 = float4x4(310.702454f, 147.866211f, 506.658875f, -435.778564f, 210.672913f, -218.781464f, -19.1908569f, 416.511719f, 427.0136f, 417.1994f, -150.911835f, 488.985535f, -294.738739f, -357.298035f, 288.771667f, 453.429138f);
+            float b2 = (417.4049f);
+            float4x4 r2 = float4x4(0.744367063f, 0.354251266f, 1.21383071f, -1.04401875f, 0.504720747f, -0.524146855f, -0.0459765978f, 0.997860134f, 1.02302015f, 0.999507666f, -0.361547828f, 1.17148972f, -0.706121862f, -0.855998635f, 0.6918262f, 1.08630526f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float4x4 a3 = float4x4(70.72443f, 425.5282f, 109.519714f, 351.8073f, -397.334045f, 497.315979f, -18.0651855f, 452.228577f, 511.858521f, -439.3021f, -441.080261f, -360.325928f, -44.2648f, -122.1008f, -322.191162f, -155.780457f);
+            float b3 = (-235.7775f);
+            float4x4 r3 = float4x4(-0.29996258f, -1.80478716f, -0.46450454f, -1.49211574f, 1.68520772f, -2.10925984f, 0.07661963f, -1.9180311f, -2.17093873f, 1.86320615f, 1.87074792f, 1.52824557f, 0.187739715f, 0.5178645f, 1.36650515f, 0.6607096f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_div_scalar_wide()
+        {
+            float a0 = (41.73767f);
+            float4x4 b0 = float4x4(-422.676147f, 248.129639f, 449.391357f, 245.858154f, -326.6206f, 163.715088f, 333.6645f, 38.2910767f, -472.979767f, 192.230164f, -200.296875f, -490.181519f, -211.10257f, -322.852356f, -137.985291f, 84.32971f);
+            float4x4 r0 = float4x4(-0.09874622f, 0.168209136f, 0.0928759947f, 0.169763222f, -0.1277864f, 0.2549409f, 0.125088736f, 1.0900104f, -0.0882440954f, 0.217123419f, -0.208379045f, -0.08514738f, -0.197712749f, -0.129277885f, -0.302479118f, 0.49493435f);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            float a1 = (355.063477f);
+            float4x4 b1 = float4x4(276.427246f, -382.988037f, -488.647156f, 344.846f, 168.85498f, -44.1955872f, 420.55072f, -175.6152f, -9.220581f, -344.194275f, -449.0715f, 117.704895f, -337.0274f, 239.393433f, -389.355164f, 242.716064f);
+            float4x4 r1 = float4x4(1.28447354f, -0.927087665f, -0.7266255f, 1.02962911f, 2.10277176f, -8.033913f, 0.84428215f, -2.02182651f, -38.5077133f, -1.03157866f, -0.790661335f, 3.0165565f, -1.0535152f, 1.48317969f, -0.911927f, 1.46287584f);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            float a2 = (496.2765f);
+            float4x4 b2 = float4x4(91.74579f, -490.492126f, 485.755432f, -317.572266f, -451.6248f, 394.018372f, -262.271423f, -314.246765f, 359.9159f, -101.615356f, 359.517273f, -424.9799f, -192.719574f, -169.749725f, -244.790009f, -187.14386f);
+            float4x4 r2 = float4x4(5.40925646f, -1.011793f, 1.02165914f, -1.56271982f, -1.09886909f, 1.25952625f, -1.89222479f, -1.57925725f, 1.378868f, -4.883873f, 1.38039684f, -1.16776466f, -2.57512236f, -2.92357755f, -2.027356f, -2.651845f);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            float a3 = (-207.713654f);
+            float4x4 b3 = float4x4(-370.154053f, 58.67694f, -123.147f, 208.8916f, -79.53113f, -219.674774f, -483.159332f, -90.52664f, 194.599976f, -4.09060669f, 270.735962f, 432.586182f, 376.047668f, 464.836731f, -322.9417f, -220.897583f);
+            float4x4 r3 = float4x4(0.5611546f, -3.53995371f, 1.686713f, -0.994361f, 2.61172771f, 0.9455508f, 0.429907143f, 2.294503f, -1.06738782f, 50.7782021f, -0.76721853f, -0.4801671f, -0.5523599f, -0.446852922f, 0.6431924f, 0.940316558f);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mod_wide_wide()
+        {
+            float4x4 a0 = float4x4(-442.309875f, 368.5005f, -1.09390259f, -364.673828f, -197.343933f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -463.368378f, 83.83911f, -64.71405f, 295.066833f, 212.25708f, 349.6283f);
+            float4x4 b0 = float4x4(-43.2450562f, -144.195862f, -62.6404724f, -336.828247f, -154.61026f, -154.029358f, 487.0462f, -469.8291f, -145.203766f, -203.384f, -22.52008f, 224.69f, -435.62674f, 12.0955811f, 40.3787842f, 345.784851f);
+            float4x4 r0 = float4x4(-9.859314f, 80.1087646f, -1.09390259f, -27.8455811f, -42.7336731f, -34.0349121f, -101.348572f, 208.318542f, -140.770325f, 183.44696f, -12.9667664f, 83.83911f, -64.71405f, 4.772888f, 10.3631592f, 3.84344482f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x4 a1 = float4x4(119.875916f, -37.8058167f, 142.41156f, 332.244263f, -464.194275f, -296.147827f, 225.175354f, -212.060272f, 156.985718f, 507.6183f, 270.830444f, 337.7343f, 384.915833f, 432.5182f, 154.292725f, -37.0853271f);
+            float4x4 b1 = float4x4(-433.471252f, -355.649963f, 4.015442f, 66.65979f, -221.853638f, -355.056763f, 357.935974f, 71.3753052f, -131.4183f, -473.9876f, 76.2178345f, 92.2102051f, -368.189575f, -77.46716f, 135.230591f, 274.277283f);
+            float4x4 r1 = float4x4(119.875916f, -37.8058167f, 1.87109375f, 65.6051f, -20.487f, -296.147827f, 225.175354f, -69.30966f, 25.5674133f, 33.6306763f, 42.17694f, 61.1037f, 16.7262573f, 45.182373f, 19.0621338f, -37.0853271f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x4 a2 = float4x4(7.76147461f, 238.094727f, 12.8520508f, -100.240662f, 34.552002f, -251.189758f, -238.372253f, 511.514648f, 288.433533f, 367.109863f, 44.760437f, -437.0456f, -259.2056f, -228.565826f, 83.49725f, 424.367065f);
+            float4x4 b2 = float4x4(132.180237f, -179.877319f, 51.9685669f, 367.214233f, -395.2128f, 270.485229f, -73.104126f, 89.3499756f, -288.308533f, -168.324646f, 311.6159f, -468.341949f, 381.983948f, -1.39886475f, -102.288605f, -87.4248657f);
+            float4x4 r2 = float4x4(7.76147461f, 58.2174072f, 12.8520508f, -100.240662f, 34.552002f, -251.189758f, -19.0598755f, 64.76477f, 0.125f, 30.4605713f, 44.760437f, -437.0456f, -259.2056f, -0.5508728f, 83.49725f, 74.6676f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x4 a3 = float4x4(327.2317f, 149.181763f, -392.158752f, -453.4767f, 480.8224f, 3.46044922f, -184.5924f, -181.417542f, -367.704224f, 146.0993f, 280.120728f, -282.483154f, 57.22583f, -432.671722f, -231.465637f, -228.28299f);
+            float4x4 b3 = float4x4(-58.42514f, -419.004883f, 479.817017f, -406.982849f, -371.595947f, 154.043213f, -444.750916f, -53.98001f, -168.831787f, -69.39877f, -380.760681f, 208.145569f, 194.436646f, 142.8681f, 413.1582f, -375.159424f);
+            float4x4 r3 = float4x4(35.1059875f, 149.181763f, -392.158752f, -46.493866f, 109.22644f, 3.46044922f, -184.5924f, -19.4775085f, -30.04065f, 7.301758f, 280.120728f, -74.3375854f, 57.22583f, -4.06741333f, -231.465637f, -228.28299f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mod_wide_scalar()
+        {
+            float4x4 a0 = float4x4(-433.417f, -5.51412964f, 393.3944f, 299.41156f, -120.80603f, -502.939026f, -450.807678f, 186.094788f, -84.47363f, -318.7815f, 433.4547f, -54.60019f, -172.338867f, -429.714661f, 222.361877f, 5.79638672f);
+            float b0 = (-90.49924f);
+            float4x4 r0 = float4x4(-71.4200439f, -5.51412964f, 31.39746f, 27.9138489f, -30.3067932f, -50.44284f, -88.81073f, 5.09631348f, -84.47363f, -47.283783f, 71.45776f, -54.60019f, -81.83963f, -67.71771f, 41.3634033f, 5.79638672f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float4x4 a1 = float4x4(254.5108f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 483.5506f, -331.993347f, 336f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 405.773621f, -194.761444f);
+            float b1 = (-433.0937f);
+            float4x4 r1 = float4x4(254.5108f, -203.082611f, -75.3564148f, 252.289124f, -69.4039f, 5.337219f, -279.060425f, 50.45691f, -331.993347f, 336f, 67.8396f, -124.720764f, 38.1759033f, 271.287f, 405.773621f, -194.761444f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float4x4 a2 = float4x4(235.724f, -304.153168f, -295.520264f, 313.7224f, -232.202637f, 191.619751f, 244.096619f, 162.524231f, 390.016174f, 90.00452f, 155.933533f, 217.3377f, -306.819275f, 149.09375f, 503.828369f, -194.130127f);
+            float b2 = (465.984863f);
+            float4x4 r2 = float4x4(235.724f, -304.153168f, -295.520264f, 313.7224f, -232.202637f, 191.619751f, 244.096619f, 162.524231f, 390.016174f, 90.00452f, 155.933533f, 217.3377f, -306.819275f, 149.09375f, 37.8435059f, -194.130127f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float4x4 a3 = float4x4(214.863037f, 225.9964f, -102.913971f, -173.706085f, 490.904663f, 501.148621f, 160.454834f, 327.860962f, -300.812683f, -326.939026f, -6.64724731f, -201.184448f, 389.350464f, -78.06848f, -484.3189f, -371.838745f);
+            float b3 = (198.770081f);
+            float4x4 r3 = float4x4(16.0929565f, 27.2263184f, -102.913971f, -173.706085f, 93.3645f, 103.608459f, 160.454834f, 129.090881f, -102.0426f, -128.168945f, -6.64724731f, -2.41436768f, 190.580383f, -78.06848f, -86.77875f, -173.068665f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_mod_scalar_wide()
+        {
+            float a0 = (-396.4224f);
+            float4x4 b0 = float4x4(-159.140259f, 230.17334f, 14.7793579f, -303.1565f, 399.635f, 206.6947f, 397.0448f, -393.890656f, -372.067078f, 201.012268f, -95.566864f, -258.951477f, 106.983582f, 469.323547f, -34.80899f, 184.836548f);
+            float4x4 r0 = float4x4(-78.14188f, -166.249054f, -12.1590881f, -93.2659f, -396.4224f, -189.727692f, -396.4224f, -2.53173828f, -24.3553162f, -195.410126f, -14.1549377f, -137.470917f, -75.47165f, -396.4224f, -13.5234985f, -26.7492981f);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            float a1 = (374.79425f);
+            float4x4 b1 = float4x4(-131.872711f, -120.092865f, 4.506653f, -111.401947f, 391.54248f, -218.668884f, 196.377441f, -511.032623f, 499.9535f, -433.523071f, -163.866852f, 177.004028f, 110.650146f, 17.68457f, -95.85297f, -432.440979f);
+            float4x4 r1 = float4x4(111.048828f, 14.5156555f, 0.7420654f, 40.58841f, 374.79425f, 156.125366f, 178.416809f, 374.79425f, 374.79425f, 374.79425f, 47.0605469f, 20.7861938f, 42.84381f, 3.418274f, 87.23535f, 374.79425f);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            float a2 = (192.692078f);
+            float4x4 b2 = float4x4(-268.131775f, 271.075134f, 423.7027f, -413.233246f, 127.956238f, -298.204681f, -352.4181f, -175.607727f, -152.899292f, 34.6194458f, -380.802948f, 0.352050781f, 485.900879f, 266.150818f, 483.82074f, 11.777832f);
+            float4x4 r2 = float4x4(192.692078f, 192.692078f, 192.692078f, 192.692078f, 64.73584f, 192.692078f, 192.692078f, 17.08435f, 39.7927856f, 19.5948486f, 192.692078f, 0.120300293f, 192.692078f, 192.692078f, 192.692078f, 4.246765f);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            float a3 = (274.135864f);
+            float4x4 b3 = float4x4(313.073181f, -102.217438f, -88.03519f, 226.979553f, -38.68274f, -63.1578064f, 330.401917f, -304.123871f, 411.681519f, 128.217773f, 48.9116821f, -58.8946533f, 29.2827148f, -328.672241f, -511.7139f, -338.5105f);
+            float4x4 r3 = float4x4(274.135864f, 69.70099f, 10.030304f, 47.15631f, 3.35668945f, 21.5046387f, 274.135864f, 274.135864f, 274.135864f, 17.7003174f, 29.5774536f, 38.55725f, 10.5914307f, 274.135864f, 274.135864f, 274.135864f);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_plus()
+        {
+            float4x4 a0 = float4x4(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f);
+            float4x4 r0 = float4x4(271.670837f, -79.08023f, -330.985046f, 31.824707f, 315.449524f, 319.222168f, 190.324646f, -350.3086f, -320.518463f, 102.054382f, -107.00351f, -428.7762f, 377.230164f, 234.773926f, 34.28363f, 258.330383f);
+            TestUtils.AreEqual(+a0, r0);
+
+            float4x4 a1 = float4x4(465.355957f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f);
+            float4x4 r1 = float4x4(465.355957f, -316.937134f, -230.052673f, 301.7851f, 2.58575439f, 350.2464f, 60.8197632f, -472.4421f, -364.802551f, 239.152344f, 473.803162f, 285.80896f, -273.2638f, -206.686371f, -113.362305f, -351.754883f);
+            TestUtils.AreEqual(+a1, r1);
+
+            float4x4 a2 = float4x4(-116.536224f, -330.005341f, -379.674255f, -339.673218f, -29.0835266f, 62.20111f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f);
+            float4x4 r2 = float4x4(-116.536224f, -330.005341f, -379.674255f, -339.673218f, -29.0835266f, 62.20111f, 485.926636f, 183.724854f, -258.392456f, 486.4469f, 245.9909f, 231.854675f, -216.48996f, -163.009186f, 175.325439f, 404.378f);
+            TestUtils.AreEqual(+a2, r2);
+
+            float4x4 a3 = float4x4(87.64923f, -236.109039f, 6.508911f, 481.885681f, -368.854034f, 82.67334f, 120.19519f, -7.73321533f, 168.252075f, -431.930176f, 228.521545f, -124.117523f, 464.7453f, -203.259216f, -505.6412f, 434.978638f);
+            float4x4 r3 = float4x4(87.64923f, -236.109039f, 6.508911f, 481.885681f, -368.854034f, 82.67334f, 120.19519f, -7.73321533f, 168.252075f, -431.930176f, 228.521545f, -124.117523f, 464.7453f, -203.259216f, -505.6412f, 434.978638f);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_neg()
+        {
+            float4x4 a0 = float4x4(420.227173f, -196.2575f, -335.426819f, 509.04364f, -33.0144043f, -498.575317f, -495.837952f, -270.859467f, 19.68689f, 268.2367f, -180.600525f, 223.381287f, -410.392059f, -395.681549f, -349.149475f, -110.9393f);
+            float4x4 r0 = float4x4(-420.227173f, 196.2575f, 335.426819f, -509.04364f, 33.0144043f, 498.575317f, 495.837952f, 270.859467f, -19.68689f, -268.2367f, 180.600525f, -223.381287f, 410.392059f, 395.681549f, 349.149475f, 110.9393f);
+            TestUtils.AreEqual(-a0, r0);
+
+            float4x4 a1 = float4x4(-238.2196f, 469.2926f, 48.29071f, 88.7237549f, 66.1485f, 55.7080078f, 464.541382f, 499.2428f, 175.015015f, 196.387573f, -306.1656f, 149.660034f, 320.391724f, -359.8338f, 22.0384521f, -159.55426f);
+            float4x4 r1 = float4x4(238.2196f, -469.2926f, -48.29071f, -88.7237549f, -66.1485f, -55.7080078f, -464.541382f, -499.2428f, -175.015015f, -196.387573f, 306.1656f, -149.660034f, -320.391724f, 359.8338f, -22.0384521f, 159.55426f);
+            TestUtils.AreEqual(-a1, r1);
+
+            float4x4 a2 = float4x4(419.822449f, 363.716736f, 280.887878f, -270.6513f, -201.615753f, 325.031616f, 95.48926f, 191.070251f, 371.973572f, 296.512573f, -164.169922f, -347.4581f, -237.404968f, -228.701965f, 61.0822754f, 128.331543f);
+            float4x4 r2 = float4x4(-419.822449f, -363.716736f, -280.887878f, 270.6513f, 201.615753f, -325.031616f, -95.48926f, -191.070251f, -371.973572f, -296.512573f, 164.169922f, 347.4581f, 237.404968f, 228.701965f, -61.0822754f, -128.331543f);
+            TestUtils.AreEqual(-a2, r2);
+
+            float4x4 a3 = float4x4(331.2558f, -501.0288f, 160.5802f, -180.496582f, 127.978333f, 260.034546f, -287.968262f, -502.199127f, 303.970581f, -182.962921f, 322.327637f, 91.48047f, 211.295166f, 116.070496f, 309.361023f, -129.064484f);
+            float4x4 r3 = float4x4(-331.2558f, 501.0288f, -160.5802f, 180.496582f, -127.978333f, -260.034546f, 287.968262f, 502.199127f, -303.970581f, 182.962921f, -322.327637f, -91.48047f, -211.295166f, -116.070496f, -309.361023f, 129.064484f);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_prefix_inc()
+        {
+            float4x4 a0 = float4x4(-99.79556f, 458.741821f, 96.1790161f, -48.55246f, -315.728973f, -299.230164f, -323.614868f, -456.8903f, -76.50766f, -305.584778f, 64.0965f, 148.679321f, 363.2849f, -115.559235f, -326.8778f, -179.894653f);
+            float4x4 r0 = float4x4(-98.79556f, 459.741821f, 97.1790161f, -47.55246f, -314.728973f, -298.230164f, -322.614868f, -455.8903f, -75.50766f, -304.584778f, 65.0965f, 149.679321f, 364.2849f, -114.559235f, -325.8778f, -178.894653f);
+            TestUtils.AreEqual(++a0, r0);
+
+            float4x4 a1 = float4x4(339.8766f, -153.373688f, 261.625549f, 155.030823f, -396.650238f, 301.3058f, -221.355408f, -429.698151f, -271.2893f, -264.380066f, -377.5592f, 223.232422f, -71.076355f, -388.2279f, 131.283142f, 22.3049316f);
+            float4x4 r1 = float4x4(340.8766f, -152.373688f, 262.625549f, 156.030823f, -395.650238f, 302.3058f, -220.355408f, -428.698151f, -270.2893f, -263.380066f, -376.5592f, 224.232422f, -70.076355f, -387.2279f, 132.283142f, 23.3049316f);
+            TestUtils.AreEqual(++a1, r1);
+
+            float4x4 a2 = float4x4(-480.760468f, 117.9541f, 139.525818f, 335.6897f, 162.6615f, -256.0451f, -254.7315f, -89.25604f, 314.36554f, 244.728149f, 34.01062f, -90.44528f, -472.63623f, -34.5667725f, -71.27185f, -396.4901f);
+            float4x4 r2 = float4x4(-479.760468f, 118.9541f, 140.525818f, 336.6897f, 163.6615f, -255.0451f, -253.7315f, -88.25604f, 315.36554f, 245.728149f, 35.01062f, -89.44528f, -471.63623f, -33.5667725f, -70.27185f, -395.4901f);
+            TestUtils.AreEqual(++a2, r2);
+
+            float4x4 a3 = float4x4(-314.987457f, 63.45038f, 474.6681f, 257.173584f, 128.107178f, -354.5639f, -194.465576f, -130.854309f, 467.560364f, 477.1499f, -458.055664f, -168.122711f, 506.568665f, -429.356873f, 444.8133f, -385.6256f);
+            float4x4 r3 = float4x4(-313.987457f, 64.45038f, 475.6681f, 258.173584f, 129.107178f, -353.5639f, -193.465576f, -129.854309f, 468.560364f, 478.1499f, -457.055664f, -167.122711f, 507.568665f, -428.356873f, 445.8133f, -384.6256f);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_postfix_inc()
+        {
+            float4x4 a0 = float4x4(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f);
+            float4x4 r0 = float4x4(322.943542f, 472.0525f, 203.48761f, -49.8545837f, -31.4205322f, 455.3366f, 271.454651f, 55.7368774f, 153.7503f, -174.173f, -427.401062f, 215.110229f, 159.861023f, -333.050446f, 241.4649f, 287.220459f);
+            TestUtils.AreEqual(a0++, r0);
+
+            float4x4 a1 = float4x4(-170.104645f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f);
+            float4x4 r1 = float4x4(-170.104645f, -162.86026f, 454.488831f, -449.9273f, 209.522644f, -311.435852f, 69.7314453f, -232.299652f, -341.498535f, 188.006592f, 417.7298f, 25.5656738f, -463.725647f, 504.448975f, -310.144958f, -117.398468f);
+            TestUtils.AreEqual(a1++, r1);
+
+            float4x4 a2 = float4x4(403.508728f, 446.607666f, -12.35257f, -232.150116f, 64.57703f, -10.5907288f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f);
+            float4x4 r2 = float4x4(403.508728f, 446.607666f, -12.35257f, -232.150116f, 64.57703f, -10.5907288f, 193.584351f, 382.050354f, -462.064117f, -122.30658f, 428.7763f, 338.97876f, 227.544067f, -169.321228f, -95.7655945f, -169.855347f);
+            TestUtils.AreEqual(a2++, r2);
+
+            float4x4 a3 = float4x4(439.3f, -424.349731f, 63.8623657f, 260.8709f, 350.9854f, 271.488342f, -378.243835f, -329.554932f, -201.921967f, -244.669952f, 365.7249f, -481.8288f, 105.475952f, -166.622009f, 394.7439f, -179.4913f);
+            float4x4 r3 = float4x4(439.3f, -424.349731f, 63.8623657f, 260.8709f, 350.9854f, 271.488342f, -378.243835f, -329.554932f, -201.921967f, -244.669952f, 365.7249f, -481.8288f, 105.475952f, -166.622009f, 394.7439f, -179.4913f);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_prefix_dec()
+        {
+            float4x4 a0 = float4x4(-416.201233f, -96.63788f, -50.14566f, -207.316437f, 439.479065f, -304.400818f, 337.968933f, 246.088989f, 171.964539f, -227.44281f, 298.2848f, 326.5078f, 400.7209f, -478.031372f, -326.452972f, -24.5845032f);
+            float4x4 r0 = float4x4(-417.201233f, -97.63788f, -51.14566f, -208.316437f, 438.479065f, -305.400818f, 336.968933f, 245.088989f, 170.964539f, -228.44281f, 297.2848f, 325.5078f, 399.7209f, -479.031372f, -327.452972f, -25.5845032f);
+            TestUtils.AreEqual(--a0, r0);
+
+            float4x4 a1 = float4x4(112.796875f, -503.27417f, -79.6352539f, -131.00415f, 147.893677f, -15.7086487f, 188.758423f, 307.791931f, -406.667725f, 181.4751f, -188.69223f, -505.2157f, -372.241943f, -4.031769f, 83.76776f, -30.6314087f);
+            float4x4 r1 = float4x4(111.796875f, -504.27417f, -80.6352539f, -132.00415f, 146.893677f, -16.7086487f, 187.758423f, 306.791931f, -407.667725f, 180.4751f, -189.69223f, -506.2157f, -373.241943f, -5.031769f, 82.76776f, -31.6314087f);
+            TestUtils.AreEqual(--a1, r1);
+
+            float4x4 a2 = float4x4(-436.906555f, 345.021545f, 4.73535156f, -68.65332f, 481.4961f, 463.391418f, -357.673279f, 153.329651f, -233.624329f, -35.23831f, 340.619629f, 259.928833f, 335.354919f, 85.36487f, -1.39398193f, -407.4104f);
+            float4x4 r2 = float4x4(-437.906555f, 344.021545f, 3.73535156f, -69.65332f, 480.4961f, 462.391418f, -358.673279f, 152.329651f, -234.624329f, -36.23831f, 339.619629f, 258.928833f, 334.354919f, 84.36487f, -2.393982f, -408.4104f);
+            TestUtils.AreEqual(--a2, r2);
+
+            float4x4 a3 = float4x4(-145.793427f, -337.445435f, -464.6742f, 226.802917f, 15.3192139f, 431.0708f, 273.0959f, -3.10839844f, 334.1468f, 26.1240845f, 14.6611938f, 239.304688f, 32.2064819f, 288.589f, -297.4829f, -154.860779f);
+            float4x4 r3 = float4x4(-146.793427f, -338.445435f, -465.6742f, 225.802917f, 14.3192139f, 430.0708f, 272.0959f, -4.10839844f, 333.1468f, 25.1240845f, 13.6611938f, 238.304688f, 31.2064819f, 287.589f, -298.4829f, -155.860779f);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void float4x4_operator_postfix_dec()
+        {
+            float4x4 a0 = float4x4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f);
+            float4x4 r0 = float4x4(-376.5924f, 16.9697266f, -0.2506714f, -202.323273f, 409.557556f, 47.85663f, -281.1117f, -262.0626f, -182.405731f, 450.1281f, -129.232666f, -332.154968f, -261.0089f, 205.461121f, -230.227783f, -483.066528f);
+            TestUtils.AreEqual(a0--, r0);
+
+            float4x4 a1 = float4x4(378.641235f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f);
+            float4x4 r1 = float4x4(378.641235f, -192.177856f, -357.0542f, -396.302063f, 279.424255f, 115.867737f, -20.8232117f, 323.4054f, 379.156128f, 311.299f, 409.222473f, -428.2567f, -425.2884f, -194.6413f, -258.848358f, -208.985779f);
+            TestUtils.AreEqual(a1--, r1);
+
+            float4x4 a2 = float4x4(-313.4259f, 176.78949f, -370.7863f, 64.90387f, 449.637756f, -112.105042f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f);
+            float4x4 r2 = float4x4(-313.4259f, 176.78949f, -370.7863f, 64.90387f, 449.637756f, -112.105042f, -203.437408f, 417.137329f, -197.347351f, 446.023376f, 239.974548f, 350.618042f, -264.747253f, 186.44165f, 353.759521f, 68.23419f);
+            TestUtils.AreEqual(a2--, r2);
+
+            float4x4 a3 = float4x4(-240.610687f, -269.286316f, -101.805145f, -492.290375f, -507.078247f, 413.102f, -491.42746f, -13.7286682f, -481.5986f, 248.557617f, -178.3342f, -345.805847f, -269.117371f, 132.769409f, -382.384277f, 388.8308f);
+            float4x4 r3 = float4x4(-240.610687f, -269.286316f, -101.805145f, -492.290375f, -507.078247f, 413.102f, -491.42746f, -13.7286682f, -481.5986f, 248.557617f, -178.3342f, -345.805847f, -269.117371f, 132.769409f, -382.384277f, 388.8308f);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..84f7f600d1eec5ae034c34e74aafdcd4bf5effc9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestFloat4x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b3a17e2bf2fb0984b96ba8a21a08b8b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs
new file mode 100644
index 0000000000000000000000000000000000000000..7cd963e2ee976bd77f17a6e2b58cc881e33d8086
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs
@@ -0,0 +1,445 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+using System;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public partial class TestHalf
+    {
+        [TestCompiler]
+        public static void half_zero()
+        {
+            TestUtils.AreEqual(half.zero.value, 0x0000);
+        }
+
+        [TestCompiler]
+        public static void half2_zero()
+        {
+            TestUtils.AreEqual(half2.zero.x.value, 0x0000);
+            TestUtils.AreEqual(half2.zero.y.value, 0x0000);
+        }
+
+        [TestCompiler]
+        public static void half3_zero()
+        {
+            TestUtils.AreEqual(half3.zero.x.value, 0x0000);
+            TestUtils.AreEqual(half3.zero.y.value, 0x0000);
+            TestUtils.AreEqual(half3.zero.z.value, 0x0000);
+        }
+
+        [TestCompiler]
+        public static void half4_zero()
+        {
+            TestUtils.AreEqual(half4.zero.x.value, 0x0000);
+            TestUtils.AreEqual(half4.zero.y.value, 0x0000);
+            TestUtils.AreEqual(half4.zero.z.value, 0x0000);
+            TestUtils.AreEqual(half4.zero.w.value, 0x0000);
+        }
+
+        [TestCompiler]
+        public static void half_from_float_construction()
+        {
+            TestUtils.AreEqual(half(0.0f).value, 0x0000);
+            TestUtils.AreEqual(half(2.98e-08f).value, 0x0000);
+            TestUtils.AreEqual(half(5.96046448e-08f).value, 0x0001);
+            TestUtils.AreEqual(half(123.4f).value, 0x57B6);
+            TestUtils.AreEqual(half(65504.0f).value, 0x7BFF);
+            TestUtils.AreEqual(half(65520.0f).value, 0x7C00);
+            TestUtils.AreEqual(half(float.PositiveInfinity).value, 0x7C00);
+            TestUtils.AreEqual(half(float.NaN).value, 0xFE00);
+
+            TestUtils.AreEqual(half(-2.98e-08f).value, 0x8000);
+            TestUtils.AreEqual(half(-5.96046448e-08f).value, 0x8001);
+            TestUtils.AreEqual(half(-123.4f).value, 0xD7B6);
+            TestUtils.AreEqual(half(-65504.0f).value, 0xFBFF);
+            TestUtils.AreEqual(half(-65520.0f).value, 0xFC00);
+            TestUtils.AreEqual(half(float.NegativeInfinity).value, 0xFC00);
+        }
+        
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half_from_float_construction_signed_zero()
+        {
+            TestUtils.AreEqual(half(-0.0f).value, 0x8000);
+        }
+
+        [TestCompiler]
+        public static void half2_from_float2_construction()
+        {
+            half2 h0 = half2(float2(0.0f, 2.98e-08f));
+            half2 h1 = half2(float2(5.96046448e-08f, 123.4f));
+            half2 h2 = half2(float2(65504.0f, 65520.0f));
+            half2 h3 = half2(float2(float.PositiveInfinity, float.NaN));
+
+            half2 h4 = half2(float2(-2.98e-08f, -5.96046448e-08f));
+            half2 h5 = half2(float2(-123.4f, -65504.0f));
+            half2 h6 = half2(float2(-65520.0f, float.NegativeInfinity));
+            half2 h7 = half2(float2(float.NegativeInfinity, 0.0f));
+
+            TestUtils.AreEqual(uint2(h0.x.value, h0.y.value), uint2(0x0000, 0x0000));
+            TestUtils.AreEqual(uint2(h1.x.value, h1.y.value), uint2(0x0001, 0x57B6));
+            TestUtils.AreEqual(uint2(h2.x.value, h2.y.value), uint2(0x7BFF, 0x7C00));
+            TestUtils.AreEqual(uint2(h3.x.value, h3.y.value), uint2(0x7C00, 0xFE00));
+
+            TestUtils.AreEqual(uint2(h4.x.value, h4.y.value), uint2(0x8000, 0x8001));
+            TestUtils.AreEqual(uint2(h5.x.value, h5.y.value), uint2(0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint2(h6.x.value, h6.y.value), uint2(0xFC00, 0xFC00));
+            TestUtils.AreEqual(uint2(h7.x.value, h7.y.value), uint2(0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half2_from_float2_construction_signed_zero()
+        {
+            half2 h0 = half2(float2(-0.0f, -0.0f));
+            TestUtils.AreEqual(uint2(h0.x.value, h0.y.value), uint2(0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void half3_from_float3_construction()
+        {
+            half3 h0 = half3(float3(0.0f, 2.98e-08f, 5.96046448e-08f));
+            half3 h1 = half3(float3(123.4f, 65504.0f, 65520.0f));
+            half3 h2 = half3(float3(float.PositiveInfinity, float.NaN, -2.98e-08f));
+            half3 h3 = half3(float3(-5.96046448e-08f, -123.4f, -65504.0f));
+            half3 h4 = half3(float3(-65520.0f, float.NegativeInfinity, 0.0f));
+
+            TestUtils.AreEqual(uint3(h0.x.value, h0.y.value, h0.z.value), uint3(0x0000, 0x0000, 0x0001));
+            TestUtils.AreEqual(uint3(h1.x.value, h1.y.value, h1.z.value), uint3(0x57B6, 0x7BFF, 0x7C00));
+            TestUtils.AreEqual(uint3(h2.x.value, h2.y.value, h2.z.value), uint3(0x7C00, 0xFE00, 0x8000));
+
+            TestUtils.AreEqual(uint3(h3.x.value, h3.y.value, h3.z.value), uint3(0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint3(h4.x.value, h4.y.value, h4.z.value), uint3(0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half3_from_float3_construction_signed_zero()
+        {
+            half3 h0 = half3(float3(-0.0f, -0.0f, -0.0f));
+            TestUtils.AreEqual(uint3(h0.x.value, h0.y.value, h0.z.value), uint3(0x8000, 0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void half4_from_float4_construction()
+        {
+            half4 h0 = half4(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f));
+            half4 h1 = half4(float4(65504.0f, 65520.0f, float.PositiveInfinity, float.NaN));
+            half4 h2 = half4(float4(-2.98e-08f, -5.96046448e-08f, -123.4f, -65504.0f));
+            half4 h3 = half4(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f));
+
+            TestUtils.AreEqual(uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value), uint4(0x0000, 0x0000, 0x0001, 0x57B6));
+            TestUtils.AreEqual(uint4(h1.x.value, h1.y.value, h1.z.value, h1.w.value), uint4(0x7BFF, 0x7C00, 0x7C00, 0xFE00));
+            TestUtils.AreEqual(uint4(h2.x.value, h2.y.value, h2.z.value, h2.w.value), uint4(0x8000, 0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value), uint4(0xFC00, 0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half4_from_float4_construction_signed_zero()
+        {
+            half4 h0 = half4(float4(-0.0f, -0.0f, -0.0f, -0.0f));
+            TestUtils.AreEqual(uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value), uint4(0x8000, 0x8000, 0x8000, 0x8000));
+        }
+
+
+        [TestCompiler]
+        public static void half_from_double_construction()
+        {
+            TestUtils.AreEqual(half(0.0).value, 0x0000);
+            TestUtils.AreEqual(half(2.98e-08).value, 0x0000);
+            TestUtils.AreEqual(half(5.96046448e-08).value, 0x0001);
+            TestUtils.AreEqual(half(123.4).value, 0x57B6);
+            TestUtils.AreEqual(half(65504.0).value, 0x7BFF);
+            TestUtils.AreEqual(half(65520.0).value, 0x7C00);
+            TestUtils.AreEqual(half(double.PositiveInfinity).value, 0x7C00);
+            TestUtils.AreEqual(half(double.NaN).value, 0xFE00);
+
+            TestUtils.AreEqual(half(-2.98e-08).value, 0x8000);
+            TestUtils.AreEqual(half(-5.96046448e-08).value, 0x8001);
+            TestUtils.AreEqual(half(-123.4).value, 0xD7B6);
+            TestUtils.AreEqual(half(-65504.0).value, 0xFBFF);
+            TestUtils.AreEqual(half(-65520.0).value, 0xFC00);
+            TestUtils.AreEqual(half(double.NegativeInfinity).value, 0xFC00);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half_from_double_construction_signed_zero()
+        {
+            TestUtils.AreEqual(half(-0.0).value, 0x8000);
+        }
+
+        [TestCompiler]
+        public static void half2_from_double2_construction()
+        {
+            half2 h0 = half2(double2(0.0, 2.98e-08));
+            half2 h1 = half2(double2(5.96046448e-08, 123.4));
+            half2 h2 = half2(double2(65504.0, 65520.0));
+            half2 h3 = half2(double2(double.PositiveInfinity, double.NaN));
+
+            half2 h4 = half2(double2(-2.98e-08, -5.96046448e-08));
+            half2 h5 = half2(double2(-123.4, -65504.0));
+            half2 h6 = half2(double2(-65520.0, double.NegativeInfinity));
+            half2 h7 = half2(double2(double.NegativeInfinity, 0.0));
+
+            TestUtils.AreEqual(uint2(h0.x.value, h0.y.value), uint2(0x0000, 0x0000));
+            TestUtils.AreEqual(uint2(h1.x.value, h1.y.value), uint2(0x0001, 0x57B6));
+            TestUtils.AreEqual(uint2(h2.x.value, h2.y.value), uint2(0x7BFF, 0x7C00));
+            TestUtils.AreEqual(uint2(h3.x.value, h3.y.value), uint2(0x7C00, 0xFE00));
+
+            TestUtils.AreEqual(uint2(h4.x.value, h4.y.value), uint2(0x8000, 0x8001));
+            TestUtils.AreEqual(uint2(h5.x.value, h5.y.value), uint2(0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint2(h6.x.value, h6.y.value), uint2(0xFC00, 0xFC00));
+            TestUtils.AreEqual(uint2(h7.x.value, h7.y.value), uint2(0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half2_from_double2_construction_signed_zero()
+        {
+            half2 h0 = half2(double2(-0.0, -0.0));
+            TestUtils.AreEqual(uint2(h0.x.value, h0.y.value), uint2(0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void half3_from_double3_construction()
+        {
+            half3 h0 = half3(double3(0.0, 2.98e-08, 5.96046448e-08));
+            half3 h1 = half3(double3(123.4, 65504.0, 65520.0));
+            half3 h2 = half3(double3(double.PositiveInfinity, double.NaN, -2.98e-08));
+            half3 h3 = half3(double3(-5.96046448e-08, -123.4, -65504.0));
+            half3 h4 = half3(double3(-65520.0, double.NegativeInfinity, 0.0));
+
+            TestUtils.AreEqual(uint3(h0.x.value, h0.y.value, h0.z.value), uint3(0x0000, 0x0000, 0x0001));
+            TestUtils.AreEqual(uint3(h1.x.value, h1.y.value, h1.z.value), uint3(0x57B6, 0x7BFF, 0x7C00));
+            TestUtils.AreEqual(uint3(h2.x.value, h2.y.value, h2.z.value), uint3(0x7C00, 0xFE00, 0x8000));
+
+            TestUtils.AreEqual(uint3(h3.x.value, h3.y.value, h3.z.value), uint3(0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint3(h4.x.value, h4.y.value, h4.z.value), uint3(0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half3_from_double3_construction_signed_zero()
+        {
+            half3 h0 = half3(double3(-0.0, -0.0, -0.0));
+            TestUtils.AreEqual(uint3(h0.x.value, h0.y.value, h0.z.value), uint3(0x8000, 0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void half4_from_double4_construction()
+        {
+            half4 h0 = half4(double4(0.0, 2.98e-08, 5.96046448e-08, 123.4));
+            half4 h1 = half4(double4(65504.0, 65520.0, double.PositiveInfinity, double.NaN));
+            half4 h2 = half4(double4(-2.98e-08, -5.96046448e-08, -123.4, -65504.0));
+            half4 h3 = half4(double4(-65520.0, double.NegativeInfinity, double.NegativeInfinity, 0.0));
+
+            TestUtils.AreEqual(uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value), uint4(0x0000, 0x0000, 0x0001, 0x57B6));
+            TestUtils.AreEqual(uint4(h1.x.value, h1.y.value, h1.z.value, h1.w.value), uint4(0x7BFF, 0x7C00, 0x7C00, 0xFE00));
+            TestUtils.AreEqual(uint4(h2.x.value, h2.y.value, h2.z.value, h2.w.value), uint4(0x8000, 0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value), uint4(0xFC00, 0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void half4_from_double4_construction_signed_zero()
+        {
+            half4 h0 = half4(double4(-0.0, -0.0, -0.0, -0.0));
+            TestUtils.AreEqual(uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value), uint4(0x8000, 0x8000, 0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void half_to_float()
+        {
+            TestUtils.AreEqual(asuint(new half { value = 0x0000 }), 0x00000000);
+            TestUtils.AreEqual(asuint(new half { value = 0x0203 }), 0x3800C000);
+            TestUtils.AreEqual(asuint(new half { value = 0x4321 }), 0x40642000);
+            TestUtils.AreEqual(asuint(new half { value = 0x7BFF }), 0x477FE000);
+            TestUtils.AreEqual(asuint(new half { value = 0x7C00 }), 0x7F800000);
+            TestUtils.AreEqual(isnan(new half { value = 0x7C01 }), true);
+
+            TestUtils.AreEqual(asuint(new half { value = 0x8000 }), 0x80000000);
+            TestUtils.AreEqual(asuint(new half { value = 0x8203 }), 0xB800C000);
+            TestUtils.AreEqual(asuint(new half { value = 0xC321 }), 0xC0642000);
+            TestUtils.AreEqual(asuint(new half { value = 0xFBFF }), 0xC77FE000);
+            TestUtils.AreEqual(asuint(new half { value = 0xFC00 }), 0xFF800000);
+            TestUtils.AreEqual(isnan(new half { value = 0xFC01 }), true);
+        }
+
+        [TestCompiler]
+        public static void half2_to_float2()
+        {
+            half2 h0; h0.x.value = 0x0000; h0.y.value = 0x0203;
+            half2 h1; h1.x.value = 0x4321; h1.y.value = 0x7BFF;
+            half2 h2; h2.x.value = 0x7C00; h2.y.value = 0x7C00;
+            half2 h3; h3.x.value = 0x7C01; h3.y.value = 0x7C01;
+
+            half2 h4; h4.x.value = 0x8000; h4.y.value = 0x8203;
+            half2 h5; h5.x.value = 0xC321; h5.y.value = 0xFBFF;
+            half2 h6; h6.x.value = 0xFC00; h6.y.value = 0xFC00;
+            half2 h7; h7.x.value = 0xFC01; h7.y.value = 0xFC01;
+
+            TestUtils.AreEqual(asuint(h0), uint2(0x00000000, 0x3800C000));
+            TestUtils.AreEqual(asuint(h1), uint2(0x40642000, 0x477FE000));
+            TestUtils.AreEqual(asuint(h2), uint2(0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(h3)), true);
+
+            TestUtils.AreEqual(asuint(h4), uint2(0x80000000, 0xB800C000));
+            TestUtils.AreEqual(asuint(h5), uint2(0xC0642000, 0xC77FE000));
+            TestUtils.AreEqual(asuint(h6), uint2(0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(h7)), true);
+        }
+
+        [TestCompiler]
+        public static void half3_to_float3()
+        {
+            half3 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321;
+            half3 h1; h1.x.value = 0x7BFF; h1.y.value = 0x7C00; h1.z.value = 0x7C00;
+            half3 h2; h2.x.value = 0x7C01; h2.y.value = 0x7C01; h2.z.value = 0x7C01;
+
+            half3 h3; h3.x.value = 0x8000; h3.y.value = 0x8203; h3.z.value = 0xC321;
+            half3 h4; h4.x.value = 0xFBFF; h4.y.value = 0xFC00; h4.z.value = 0xFC00;
+            half3 h5; h5.x.value = 0xFC01; h5.y.value = 0xFC01; h5.z.value = 0xFC01;
+
+            TestUtils.AreEqual(asuint(h0), uint3(0x00000000, 0x3800C000, 0x40642000));
+            TestUtils.AreEqual(asuint(h1), uint3(0x477FE000, 0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(h2)), true);
+
+            TestUtils.AreEqual(asuint(h3), uint3(0x80000000, 0xB800C000, 0xC0642000));
+            TestUtils.AreEqual(asuint(h4), uint3(0xC77FE000, 0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(h5)), true);
+        }
+
+        [TestCompiler]
+        public static void half4_to_float4()
+        {
+            half4 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; h0.w.value = 0x7BFF;
+            half4 h1; h1.x.value = 0x7C00; h1.y.value = 0x7C00; h1.z.value = 0x7C00; h1.w.value = 0x7C00;
+            half4 h2; h2.x.value = 0x7C01; h2.y.value = 0x7C01; h2.z.value = 0x7C01; h2.w.value = 0x7C01;
+
+            half4 h3; h3.x.value = 0x8000; h3.y.value = 0x8203; h3.z.value = 0xC321; h3.w.value = 0xFBFF;
+            half4 h4; h4.x.value = 0xFC00; h4.y.value = 0xFC00; h4.z.value = 0xFC00; h4.w.value = 0xFC00;
+            half4 h5; h5.x.value = 0xFC01; h5.y.value = 0xFC01; h5.z.value = 0xFC01; h5.w.value = 0xFC01;
+
+            TestUtils.AreEqual(asuint(h0), uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000));
+            TestUtils.AreEqual(asuint(h1), uint4(0x7F800000, 0x7F800000, 0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(h2)), true);
+
+            TestUtils.AreEqual(asuint(h3), uint4(0x80000000, 0xB800C000, 0xC0642000, 0xC77FE000));
+            TestUtils.AreEqual(asuint(h4), uint4(0xFF800000, 0xFF800000, 0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(h5)), true);
+        }
+
+
+        [TestCompiler]
+        public static void half_to_double()
+        {
+            TestUtils.AreEqual(asulong((double)new half { value = 0x0000 }), 0x0000000000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0x0203 }), 0x3F00180000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0x4321 }), 0x400C840000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0x7BFF }), 0x40eFFC0000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0x7C00 }), 0x7FF0000000000000u);
+            TestUtils.AreEqual(isnan((double)new half { value = 0x7C01 }), true);
+
+            TestUtils.AreEqual(asulong((double)new half { value = 0x8000 }), 0x8000000000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0x8203 }), 0xBF00180000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0xC321 }), 0xC00C840000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0xFBFF }), 0xC0eFFC0000000000u);
+            TestUtils.AreEqual(asulong((double)new half { value = 0xFC00 }), 0xFFF0000000000000u);
+            TestUtils.AreEqual(isnan((double)new half { value = 0xFC01 }), true);
+        }
+
+
+        [TestCompiler]
+        public static void half_from_float_explicit_conversion()
+        {
+            half h = (half)123.4f;
+            TestUtils.AreEqual(h.value, 0x57B6);
+        }
+
+        [TestCompiler]
+        public static void half2_from_float2_explicit_conversion()
+        {
+            half2 h = (half2)float2(123.4f, 5.96046448e-08f);
+            TestUtils.AreEqual(h.x.value, 0x57B6);
+            TestUtils.AreEqual(h.y.value, 0x0001);
+        }
+
+        [TestCompiler]
+        public static void half3_from_float3_explicit_conversion()
+        {
+            half3 h = (half3)float3(123.4f, 5.96046448e-08f, -65504.0f);
+            TestUtils.AreEqual(h.x.value, 0x57B6);
+            TestUtils.AreEqual(h.y.value, 0x0001);
+            TestUtils.AreEqual(h.z.value, 0xFBFF);
+        }
+
+        [TestCompiler]
+        public static void half4_from_float4_explicit_conversion()
+        {
+            half4 h = (half4)float4(123.4f, 5.96046448e-08f, -65504.0f, float.PositiveInfinity);
+            TestUtils.AreEqual(h.x.value, 0x57B6);
+            TestUtils.AreEqual(h.y.value, 0x0001);
+            TestUtils.AreEqual(h.z.value, 0xFBFF);
+            TestUtils.AreEqual(h.w.value, 0x7C00);
+        }
+
+        [TestCompiler]
+        public static void half_from_double_explicit_conversion()
+        {
+            half h = (half)123.4;
+            TestUtils.AreEqual(h.value, 0x57B6);
+        }
+
+
+        [TestCompiler]
+        public static void half_to_float_implicit_conversion()
+        {
+            half h; h.value = 0x0203;
+            float f = h;
+            TestUtils.AreEqual(asuint(f), 0x3800C000);
+        }
+
+        [TestCompiler]
+        public static void half2_to_float2_implicit_conversion()
+        {
+            half2 h; h.x.value = 0x0203;    h.y.value = 0x8203;
+            float2 f = h;
+            TestUtils.AreEqual(asuint(f.x), 0x3800C000);
+            TestUtils.AreEqual(asuint(f.y), 0xB800C000);
+        }
+
+        [TestCompiler]
+        public static void half3_to_float3_implicit_conversion()
+        {
+            half3 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF;
+            float3 f = h;
+            TestUtils.AreEqual(asuint(f.x), 0x3800C000);
+            TestUtils.AreEqual(asuint(f.y), 0xB800C000);
+            TestUtils.AreEqual(asuint(f.z), 0x477FE000);
+        }
+
+        [TestCompiler]
+        public static void half4_to_float4_implicit_conversion()
+        {
+            half4 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; h.w.value = 0x7C00;
+            float4 f = h;
+            TestUtils.AreEqual(asuint(f.x), 0x3800C000);
+            TestUtils.AreEqual(asuint(f.y), 0xB800C000);
+            TestUtils.AreEqual(asuint(f.z), 0x477FE000);
+            TestUtils.AreEqual(asuint(f.w), 0x7F800000);
+        }
+
+        [TestCompiler]
+        public static void half_to_double_implicit_conversion()
+        {
+            half h; h.value = 0x0203;
+            double f = h;
+
+            TestUtils.AreEqual(asulong(f), 0x3F00180000000000u);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..291a364e9eb6e875476aca5d767bb6954816aad1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestHalf.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dba01b4c9788ea04d87865908e0ba344
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..8f29d018fd34da39435ea5c7fc8941ef409f5a02
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs
@@ -0,0 +1,1339 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt2
+    {
+        [TestCompiler]
+        public static void int2_zero()
+        {
+            TestUtils.AreEqual(int2.zero.x, 0);
+            TestUtils.AreEqual(int2.zero.y, 0);
+        }
+
+        [TestCompiler]
+        public static void int2_constructor()
+        {
+            int2 a = new int2(1, 2);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+        }
+
+        [TestCompiler]
+        public static void int2_scalar_constructor()
+        {
+            int2 a = new int2(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+        }
+
+        [TestCompiler]
+        public static void int2_static_constructor()
+        {
+            int2 a = int2(1, 2);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+        }
+
+        [TestCompiler]
+        public static void int2_static_scalar_constructor()
+        {
+            int2 a = int2(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_equal_wide_wide()
+        {
+            int2 a0 = int2(790229414, 970783976);
+            int2 b0 = int2(612337669, 1214209108);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2 a1 = int2(1428432738, 1578747135);
+            int2 b1 = int2(2120643427, 295461214);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2 a2 = int2(1733797753, 2001507228);
+            int2 b2 = int2(1510890331, 1893316566);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2 a3 = int2(1446876437, 1777406370);
+            int2 b3 = int2(921816149, 1834958575);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_equal_wide_scalar()
+        {
+            int2 a0 = int2(1211464300, 1921862607);
+            int b0 = (746972502);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2 a1 = int2(508076684, 1394594555);
+            int b1 = (1249127920);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2 a2 = int2(746862310, 1884008277);
+            int b2 = (1733655277);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2 a3 = int2(1682018538, 936027116);
+            int b3 = (795585660);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int2 b0 = int2(233855098, 924242519);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1402948791);
+            int2 b1 = int2(601381975, 2120518068);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (629187703);
+            int2 b2 = int2(1971977031, 47183124);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1061805787);
+            int2 b3 = int2(1009011238, 312511148);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_not_equal_wide_wide()
+        {
+            int2 a0 = int2(1660932106, 982847023);
+            int2 b0 = int2(107139049, 75478496);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2 a1 = int2(97046264, 1739517447);
+            int2 b1 = int2(2055495054, 358586687);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2 a2 = int2(1253499180, 1830584069);
+            int2 b2 = int2(942338347, 111564990);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2 a3 = int2(1841470429, 1397841646);
+            int2 b3 = int2(113811950, 948912488);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_not_equal_wide_scalar()
+        {
+            int2 a0 = int2(747758183, 1033001286);
+            int b0 = (248693828);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2 a1 = int2(1439973882, 1197845089);
+            int b1 = (2138928797);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2 a2 = int2(1432672459, 238704450);
+            int b2 = (950170763);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2 a3 = int2(2105962247, 1640688041);
+            int b3 = (727205263);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int2 b0 = int2(2037494727, 1989050616);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (48833929);
+            int2 b1 = int2(1897435904, 514354517);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (1783749164);
+            int2 b2 = int2(364694471, 754315072);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (124108032);
+            int2 b3 = int2(1512967900, 1178825850);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_wide_wide()
+        {
+            int2 a0 = int2(1182186063, 415538999);
+            int2 b0 = int2(524633529, 1032195686);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2 a1 = int2(1667335818, 1566618442);
+            int2 b1 = int2(760723389, 1505751409);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2 a2 = int2(1166180837, 639095188);
+            int2 b2 = int2(431962172, 1287906509);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2 a3 = int2(1080836365, 771119973);
+            int2 b3 = int2(1560084663, 1450178202);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_wide_scalar()
+        {
+            int2 a0 = int2(608447185, 818840405);
+            int b0 = (1491216667);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2 a1 = int2(869219329, 1214500548);
+            int b1 = (2080125385);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2 a2 = int2(1361741203, 1615392341);
+            int b2 = (1667165786);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2 a3 = int2(840091491, 1247103789);
+            int b3 = (469591900);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int2 b0 = int2(282703327, 14370648);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1862117300);
+            int2 b1 = int2(1304793311, 826073259);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (988910157);
+            int2 b2 = int2(445132446, 1139670255);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (111349251);
+            int2 b3 = int2(1102440676, 112183144);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_wide_wide()
+        {
+            int2 a0 = int2(592884447, 2133928932);
+            int2 b0 = int2(138737040, 192863971);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2 a1 = int2(918957182, 1284069471);
+            int2 b1 = int2(1700841444, 1044631301);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2 a2 = int2(194584707, 739120780);
+            int2 b2 = int2(1391589821, 730837695);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2 a3 = int2(241654068, 1340158550);
+            int2 b3 = int2(253553987, 2078872742);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_wide_scalar()
+        {
+            int2 a0 = int2(1097138316, 211763648);
+            int b0 = (438688675);
+            bool2 r0 = bool2(true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2 a1 = int2(1883002501, 43662641);
+            int b1 = (56406996);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2 a2 = int2(1923456111, 1219010035);
+            int b2 = (1437755186);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2 a3 = int2(2125058448, 893125636);
+            int b3 = (304028799);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int2 b0 = int2(599356784, 185671342);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1932327391);
+            int2 b1 = int2(2025591013, 1257191721);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1312388500);
+            int2 b2 = int2(1443698859, 779217735);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (691047512);
+            int2 b3 = int2(741776730, 732565983);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_equal_wide_wide()
+        {
+            int2 a0 = int2(1577248162, 2043073061);
+            int2 b0 = int2(903445031, 2108974565);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2 a1 = int2(1688380407, 176431985);
+            int2 b1 = int2(210822256, 1281704747);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2 a2 = int2(223299035, 1502802140);
+            int2 b2 = int2(453681718, 66138830);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2 a3 = int2(1691709825, 386789394);
+            int2 b3 = int2(1229799377, 1620922595);
+            bool2 r3 = bool2(false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_equal_wide_scalar()
+        {
+            int2 a0 = int2(1722165358, 1219858357);
+            int b0 = (1688048545);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2 a1 = int2(860410743, 348104022);
+            int b1 = (411099660);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2 a2 = int2(1963256951, 58924407);
+            int b2 = (212084836);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2 a3 = int2(1459242706, 532949158);
+            int b3 = (1745758438);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int2 b0 = int2(1181030049, 1787703989);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1729760948);
+            int2 b1 = int2(1816537388, 1359786460);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (874999193);
+            int2 b2 = int2(1678863148, 1711365839);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (762067160);
+            int2 b3 = int2(11953554, 1131583906);
+            bool2 r3 = bool2(false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_equal_wide_wide()
+        {
+            int2 a0 = int2(263000030, 744235661);
+            int2 b0 = int2(1395535146, 1178373944);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2 a1 = int2(1893760267, 237248);
+            int2 b1 = int2(1237373760, 1364855321);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2 a2 = int2(1062370984, 1676977687);
+            int2 b2 = int2(600811864, 362060472);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2 a3 = int2(816766880, 1089431546);
+            int2 b3 = int2(290870624, 1839067862);
+            bool2 r3 = bool2(true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_equal_wide_scalar()
+        {
+            int2 a0 = int2(2112791350, 1043657935);
+            int b0 = (1470533736);
+            bool2 r0 = bool2(true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2 a1 = int2(101764761, 556026890);
+            int b1 = (1529909067);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2 a2 = int2(281734132, 815093894);
+            int b2 = (1186600258);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2 a3 = int2(609211196, 829548642);
+            int b3 = (1604309397);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int2 b0 = int2(1503244746, 861711266);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (817773856);
+            int2 b1 = int2(925984572, 571221723);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (683686810);
+            int2 b2 = int2(118252990, 1653952090);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (1240253990);
+            int2 b3 = int2(1947039008, 1869136019);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_add_wide_wide()
+        {
+            int2 a0 = int2(2049228671, 1658660009);
+            int2 b0 = int2(2088751567, 645762023);
+            int2 r0 = int2(-156987058, -1990545264);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2 a1 = int2(491719392, 937013355);
+            int2 b1 = int2(306868786, 4360271);
+            int2 r1 = int2(798588178, 941373626);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2 a2 = int2(81108663, 1063894558);
+            int2 b2 = int2(506047997, 2094559874);
+            int2 r2 = int2(587156660, -1136512864);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2 a3 = int2(86954702, 843159721);
+            int2 b3 = int2(1634712736, 1601474440);
+            int2 r3 = int2(1721667438, -1850333135);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_add_wide_scalar()
+        {
+            int2 a0 = int2(2038218457, 134923711);
+            int b0 = (2124409227);
+            int2 r0 = int2(-132339612, -2035634358);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2 a1 = int2(875689667, 997710928);
+            int b1 = (1338884463);
+            int2 r1 = int2(-2080393166, -1958371905);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2 a2 = int2(340490871, 70433301);
+            int b2 = (1067888129);
+            int2 r2 = int2(1408379000, 1138321430);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2 a3 = int2(2003021861, 1160398286);
+            int b3 = (1635971971);
+            int2 r3 = int2(-655973464, -1498597039);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int2 b0 = int2(519908870, 851424292);
+            int2 r0 = int2(911000948, 1242516370);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (328314822);
+            int2 b1 = int2(135622204, 740923360);
+            int2 r1 = int2(463937026, 1069238182);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (655394201);
+            int2 b2 = int2(1451896269, 1781697072);
+            int2 r2 = int2(2107290470, -1857876023);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (996031825);
+            int2 b3 = int2(1557774949, 779774940);
+            int2 r3 = int2(-1741160522, 1775806765);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_sub_wide_wide()
+        {
+            int2 a0 = int2(1353441118, 797269833);
+            int2 b0 = int2(1332656812, 1827794007);
+            int2 r0 = int2(20784306, -1030524174);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2 a1 = int2(659988112, 56022121);
+            int2 b1 = int2(972557431, 2078233689);
+            int2 r1 = int2(-312569319, -2022211568);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2 a2 = int2(365847472, 2062899435);
+            int2 b2 = int2(1508184327, 1372307701);
+            int2 r2 = int2(-1142336855, 690591734);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2 a3 = int2(1380988474, 799885138);
+            int2 b3 = int2(810327977, 936799885);
+            int2 r3 = int2(570660497, -136914747);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_sub_wide_scalar()
+        {
+            int2 a0 = int2(1176369558, 1934521195);
+            int b0 = (462232403);
+            int2 r0 = int2(714137155, 1472288792);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2 a1 = int2(309452150, 108910717);
+            int b1 = (1417634074);
+            int2 r1 = int2(-1108181924, -1308723357);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2 a2 = int2(1306356714, 1451794815);
+            int b2 = (1502312334);
+            int2 r2 = int2(-195955620, -50517519);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2 a3 = int2(281174200, 1913724431);
+            int b3 = (87530840);
+            int2 r3 = int2(193643360, 1826193591);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int2 b0 = int2(2022393810, 1612688515);
+            int2 r0 = int2(-330859405, 78845890);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (496689713);
+            int2 b1 = int2(887037586, 2097630964);
+            int2 r1 = int2(-390347873, -1600941251);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (374934538);
+            int2 b2 = int2(939035482, 935242277);
+            int2 r2 = int2(-564100944, -560307739);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1789300421);
+            int2 b3 = int2(264712893, 1231856067);
+            int2 r3 = int2(1524587528, 557444354);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mul_wide_wide()
+        {
+            int2 a0 = int2(245827027, 208934650);
+            int2 b0 = int2(759663997, 350129201);
+            int2 r0 = int2(-632811769, 1402281434);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2 a1 = int2(1019478917, 568231809);
+            int2 b1 = int2(477450108, 1635735015);
+            int2 r1 = int2(332447596, -1932977561);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2 a2 = int2(877289039, 1585782440);
+            int2 b2 = int2(388710278, 757722665);
+            int2 r2 = int2(-1670918566, 1455036648);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2 a3 = int2(2111178729, 1186019069);
+            int2 b3 = int2(1509388321, 1841703980);
+            int2 r3 = int2(2128344329, -594088068);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mul_wide_scalar()
+        {
+            int2 a0 = int2(1762033447, 465343930);
+            int b0 = (1476837906);
+            int2 r0 = int2(-1313177922, 1326807828);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2 a1 = int2(1570757881, 1824319147);
+            int b1 = (1326409563);
+            int2 r1 = int2(1666366339, -252064823);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2 a2 = int2(1356578909, 154616909);
+            int b2 = (72749215);
+            int2 r2 = int2(130042307, 1400257491);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2 a3 = int2(975743632, 1958912969);
+            int b3 = (573770299);
+            int2 r3 = int2(414773040, -699623085);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int2 b0 = int2(1764461774, 657072478);
+            int2 r0 = int2(-950398648, -102049016);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1459784358);
+            int2 b1 = int2(1610646683, 1632058826);
+            int2 r1 = int2(1040681602, -1659570948);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (868441654);
+            int2 b2 = int2(1408757883, 335917146);
+            int2 r2 = int2(1867178994, -1836957956);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (2105124483);
+            int2 b3 = int2(1178393968, 1963904348);
+            int2 r3 = int2(-1028919216, 2084093460);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_div_wide_wide()
+        {
+            int2 a0 = int2(1590198532, 507812502);
+            int2 b0 = int2(1434703236, 911965201);
+            int2 r0 = int2(1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2 a1 = int2(126627032, 1058247011);
+            int2 b1 = int2(390415521, 128746927);
+            int2 r1 = int2(0, 8);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2 a2 = int2(427387861, 290676154);
+            int2 b2 = int2(525835375, 816946613);
+            int2 r2 = int2(0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2 a3 = int2(1829594484, 1127868739);
+            int2 b3 = int2(878264647, 146789678);
+            int2 r3 = int2(2, 7);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_div_wide_scalar()
+        {
+            int2 a0 = int2(560951562, 1218680769);
+            int b0 = (947861580);
+            int2 r0 = int2(0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2 a1 = int2(375341724, 1919409166);
+            int b1 = (1613542090);
+            int2 r1 = int2(0, 1);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2 a2 = int2(1397425408, 524526253);
+            int b2 = (1349573078);
+            int2 r2 = int2(1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2 a3 = int2(341995568, 1515313790);
+            int b3 = (495895326);
+            int2 r3 = int2(0, 3);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int2 b0 = int2(187325733, 1594107378);
+            int2 r0 = int2(6, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (2016183849);
+            int2 b1 = int2(1589343709, 388768753);
+            int2 r1 = int2(1, 5);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1417077283);
+            int2 b2 = int2(1773486938, 1154044032);
+            int2 r2 = int2(0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (81831373);
+            int2 b3 = int2(1476877645, 653688843);
+            int2 r3 = int2(0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mod_wide_wide()
+        {
+            int2 a0 = int2(146150818, 1846543305);
+            int2 b0 = int2(983050390, 771341152);
+            int2 r0 = int2(146150818, 303861001);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2 a1 = int2(1071447756, 308965362);
+            int2 b1 = int2(942375212, 367361754);
+            int2 r1 = int2(129072544, 308965362);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2 a2 = int2(659881575, 1002365460);
+            int2 b2 = int2(749500619, 750718852);
+            int2 r2 = int2(659881575, 251646608);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2 a3 = int2(861198439, 1510617532);
+            int2 b3 = int2(2095151755, 88438806);
+            int2 r3 = int2(861198439, 7157830);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mod_wide_scalar()
+        {
+            int2 a0 = int2(164800505, 1062177828);
+            int b0 = (883951171);
+            int2 r0 = int2(164800505, 178226657);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2 a1 = int2(1898749675, 820393245);
+            int b1 = (1701653318);
+            int2 r1 = int2(197096357, 820393245);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2 a2 = int2(19002208, 1464010899);
+            int b2 = (128329633);
+            int2 r2 = int2(19002208, 52384936);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2 a3 = int2(896587769, 1982762194);
+            int b3 = (405208598);
+            int2 r3 = int2(86170573, 361927802);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int2 b0 = int2(740000543, 1556450291);
+            int2 r0 = int2(242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1104736385);
+            int2 b1 = int2(437976569, 1911837205);
+            int2 r1 = int2(228783247, 1104736385);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (1507212038);
+            int2 b2 = int2(1906405167, 247693265);
+            int2 r2 = int2(1507212038, 21052448);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (293460573);
+            int2 b3 = int2(1495295166, 873323603);
+            int2 r3 = int2(293460573, 293460573);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_plus()
+        {
+            int2 a0 = int2(1643476803, 907898539);
+            int2 r0 = int2(1643476803, 907898539);
+            TestUtils.AreEqual(+a0, r0);
+
+            int2 a1 = int2(379615839, 1735287433);
+            int2 r1 = int2(379615839, 1735287433);
+            TestUtils.AreEqual(+a1, r1);
+
+            int2 a2 = int2(1743199272, 339091479);
+            int2 r2 = int2(1743199272, 339091479);
+            TestUtils.AreEqual(+a2, r2);
+
+            int2 a3 = int2(401565897, 849339193);
+            int2 r3 = int2(401565897, 849339193);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_neg()
+        {
+            int2 a0 = int2(1955022112, 662160019);
+            int2 r0 = int2(-1955022112, -662160019);
+            TestUtils.AreEqual(-a0, r0);
+
+            int2 a1 = int2(370300775, 1004505619);
+            int2 r1 = int2(-370300775, -1004505619);
+            TestUtils.AreEqual(-a1, r1);
+
+            int2 a2 = int2(28153593, 505708349);
+            int2 r2 = int2(-28153593, -505708349);
+            TestUtils.AreEqual(-a2, r2);
+
+            int2 a3 = int2(1115028238, 694995093);
+            int2 r3 = int2(-1115028238, -694995093);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_prefix_inc()
+        {
+            int2 a0 = int2(864455342, 2035793213);
+            int2 r0 = int2(864455343, 2035793214);
+            TestUtils.AreEqual(++a0, r0);
+
+            int2 a1 = int2(1275443862, 411610189);
+            int2 r1 = int2(1275443863, 411610190);
+            TestUtils.AreEqual(++a1, r1);
+
+            int2 a2 = int2(446210725, 115573442);
+            int2 r2 = int2(446210726, 115573443);
+            TestUtils.AreEqual(++a2, r2);
+
+            int2 a3 = int2(913293639, 1208161871);
+            int2 r3 = int2(913293640, 1208161872);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_postfix_inc()
+        {
+            int2 a0 = int2(1751003569, 2063707595);
+            int2 r0 = int2(1751003569, 2063707595);
+            TestUtils.AreEqual(a0++, r0);
+
+            int2 a1 = int2(1500486291, 1007848192);
+            int2 r1 = int2(1500486291, 1007848192);
+            TestUtils.AreEqual(a1++, r1);
+
+            int2 a2 = int2(2028651936, 1190630527);
+            int2 r2 = int2(2028651936, 1190630527);
+            TestUtils.AreEqual(a2++, r2);
+
+            int2 a3 = int2(1396179607, 177416855);
+            int2 r3 = int2(1396179607, 177416855);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_prefix_dec()
+        {
+            int2 a0 = int2(200904609, 871077500);
+            int2 r0 = int2(200904608, 871077499);
+            TestUtils.AreEqual(--a0, r0);
+
+            int2 a1 = int2(968578728, 1995396216);
+            int2 r1 = int2(968578727, 1995396215);
+            TestUtils.AreEqual(--a1, r1);
+
+            int2 a2 = int2(435367037, 1589827826);
+            int2 r2 = int2(435367036, 1589827825);
+            TestUtils.AreEqual(--a2, r2);
+
+            int2 a3 = int2(1434377580, 1699290403);
+            int2 r3 = int2(1434377579, 1699290402);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_postfix_dec()
+        {
+            int2 a0 = int2(283970262, 1109329936);
+            int2 r0 = int2(283970262, 1109329936);
+            TestUtils.AreEqual(a0--, r0);
+
+            int2 a1 = int2(1073216143, 1932646215);
+            int2 r1 = int2(1073216143, 1932646215);
+            TestUtils.AreEqual(a1--, r1);
+
+            int2 a2 = int2(1174104498, 524156737);
+            int2 r2 = int2(1174104498, 524156737);
+            TestUtils.AreEqual(a2--, r2);
+
+            int2 a3 = int2(691209285, 802721301);
+            int2 r3 = int2(691209285, 802721301);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_and_wide_wide()
+        {
+            int2 a0 = int2(779935043, 1097962163);
+            int2 b0 = int2(307705143, 1710882162);
+            int2 r0 = int2(39064835, 1097961522);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2 a1 = int2(1939593304, 800599247);
+            int2 b1 = int2(866836769, 532490608);
+            int2 r1 = int2(864731136, 263727168);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2 a2 = int2(952140918, 782792558);
+            int2 b2 = int2(679371720, 1794035877);
+            int2 r2 = int2(675283008, 715673636);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2 a3 = int2(1608557706, 396446406);
+            int2 b3 = int2(1439832202, 519529812);
+            int2 r3 = int2(1438646410, 379666500);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_and_wide_scalar()
+        {
+            int2 a0 = int2(443615469, 490057985);
+            int b0 = (93423598);
+            int2 r0 = int2(1114348, 85033216);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2 a1 = int2(2042441263, 1405175110);
+            int b1 = (1524760558);
+            int2 r1 = int2(1486958126, 1388397894);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2 a2 = int2(510212004, 1236735839);
+            int b2 = (1941875181);
+            int2 r2 = int2(304619940, 1102446925);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2 a3 = int2(1365509729, 607982857);
+            int b3 = (428270198);
+            int2 r3 = int2(285475424, 262144);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int2 b0 = int2(420346723, 562416448);
+            int2 r0 = int2(547170, 18752);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1393127318);
+            int2 b1 = int2(1560699552, 851218057);
+            int2 r1 = int2(1358979712, 302517888);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (703880958);
+            int2 b2 = int2(1159378889, 2031211279);
+            int2 r2 = int2(17831624, 688935438);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1089518981);
+            int2 b3 = int2(270607307, 1349288930);
+            int2 r3 = int2(2105729, 1080066432);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_or_wide_wide()
+        {
+            int2 a0 = int2(1731159103, 659068416);
+            int2 b0 = int2(1583847161, 692672727);
+            int2 r0 = int2(2138044159, 793370327);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2 a1 = int2(382702471, 1821032196);
+            int2 b1 = int2(1161585489, 1756207130);
+            int2 r1 = int2(1476391895, 1823457054);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2 a2 = int2(1565773438, 1004000514);
+            int2 b2 = int2(1321374429, 1287357212);
+            int2 r2 = int2(1607720703, 2147473182);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2 a3 = int2(948501377, 600951835);
+            int2 b3 = int2(2075767170, 1273513430);
+            int2 r3 = int2(2075786115, 1811533279);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_or_wide_scalar()
+        {
+            int2 a0 = int2(961259683, 471103264);
+            int b0 = (1666102508);
+            int2 r0 = int2(2068823279, 2136930284);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2 a1 = int2(1733389229, 386953869);
+            int b1 = (1591585258);
+            int2 r1 = int2(2145250287, 1608383471);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2 a2 = int2(1148351449, 1814263250);
+            int b2 = (1048929715);
+            int2 r2 = int2(2130147323, 2124903923);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2 a3 = int2(860336789, 1227888278);
+            int b3 = (1637162093);
+            int2 r3 = int2(1943518973, 1773477631);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int2 b0 = int2(1212928242, 1614462616);
+            int2 r0 = int2(1213978111, 1752940445);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (936937728);
+            int2 b1 = int2(764766995, 306352095);
+            int2 r1 = int2(1071508243, 937070559);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (574719481);
+            int2 b2 = int2(1283571271, 2109131012);
+            int2 r2 = int2(1858191359, 2146946557);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (979469710);
+            int2 b3 = int2(1348323481, 1407542578);
+            int2 r3 = int2(2055064991, 2078664126);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_xor_wide_wide()
+        {
+            int2 a0 = int2(1556324760, 207002929);
+            int2 b0 = int2(1054997548, 1523759632);
+            int2 r0 = int2(1646419380, 1451501345);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2 a1 = int2(1843444873, 1632079131);
+            int2 b1 = int2(251164872, 110472397);
+            int2 r1 = int2(1662567489, 1741824470);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2 a2 = int2(1460334334, 1607815585);
+            int2 b2 = int2(384031112, 1109163205);
+            int2 r2 = int2(1105803126, 499723620);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2 a3 = int2(220623650, 38668553);
+            int2 b3 = int2(535118981, 179106262);
+            int2 r3 = int2(314783655, 149092575);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_xor_wide_scalar()
+        {
+            int2 a0 = int2(2124666952, 177397845);
+            int b0 = (493665894);
+            int2 r0 = int2(1674536494, 402546227);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2 a1 = int2(574879617, 1136545648);
+            int b1 = (1937385541);
+            int2 r1 = int2(1362747332, 818177845);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2 a2 = int2(213863690, 289301586);
+            int b2 = (535061373);
+            int2 r2 = int2(324742775, 249169711);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2 a3 = int2(1305234431, 1308626970);
+            int b3 = (353786540);
+            int2 r3 = int2(1490686291, 1528187574);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int2 b0 = int2(1077599928, 884741329);
+            int2 r0 = int2(217506340, 2020616269);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (212164516);
+            int2 b1 = int2(1585020328, 152985454);
+            int2 r1 = int2(1390158348, 96141514);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1775851275);
+            int2 b2 = int2(1416249064, 1309317737);
+            int2 r2 = int2(1035168227, 668192098);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1773918217);
+            int2 b3 = int2(1509843030, 1206045972);
+            int2 r3 = int2(809875551, 777590045);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_left_shift()
+        {
+            int2 a0 = int2(197771193, 622182602);
+            int b0 = (1321149625);
+            int2 r0 = int2(1912602624, -1811939328);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int2 a1 = int2(1283988958, 473415985);
+            int b1 = (1327917304);
+            int2 r1 = int2(-570425344, 822083584);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int2 a2 = int2(432425717, 2058433484);
+            int b2 = (870301196);
+            int2 r2 = int2(1689210880, 322748416);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int2 a3 = int2(1200694230, 1360008038);
+            int b3 = (1531607705);
+            int2 r3 = int2(-1409286144, -872415232);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_right_shift()
+        {
+            int2 a0 = int2(548167301, 1161338299);
+            int b0 = (1266801540);
+            int2 r0 = int2(34260456, 72583643);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int2 a1 = int2(1617625829, 713958715);
+            int b1 = (1860731847);
+            int2 r1 = int2(12637701, 5577802);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int2 a2 = int2(196552656, 1265099998);
+            int b2 = (770466193);
+            int2 r2 = int2(1499, 9651);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int2 a3 = int2(572763124, 426807581);
+            int b3 = (506619530);
+            int2 r3 = int2(559338, 416804);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_operator_bitwise_not()
+        {
+            int2 a0 = int2(1403358969, 831360921);
+            int2 r0 = int2(-1403358970, -831360922);
+            TestUtils.AreEqual(~a0, r0);
+
+            int2 a1 = int2(2088190243, 878283189);
+            int2 r1 = int2(-2088190244, -878283190);
+            TestUtils.AreEqual(~a1, r1);
+
+            int2 a2 = int2(308994339, 1420884856);
+            int2 r2 = int2(-308994340, -1420884857);
+            TestUtils.AreEqual(~a2, r2);
+
+            int2 a3 = int2(472965491, 627580960);
+            int2 r3 = int2(-472965492, -627580961);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2_shuffle_result_1()
+        {
+            int2 a = int2(0, 1);
+            int2 b = int2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (3));
+        }
+
+        [TestCompiler]
+        public static void int2_shuffle_result_2()
+        {
+            int2 a = int2(0, 1);
+            int2 b = int2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX), int2(0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftX), int2(1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), int2(2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX), int2(3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY), int2(0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int2(1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY), int2(2, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), int2(3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightX), int2(0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), int2(1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX), int2(2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), int2(3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY), int2(0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY), int2(1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY), int2(2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), int2(3, 3));
+        }
+
+        [TestCompiler]
+        public static void int2_shuffle_result_3()
+        {
+            int2 a = int2(0, 1);
+            int2 b = int2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY), int3(2, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightX), int3(2, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightY), int3(3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int3(1, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), int3(2, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), int3(0, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), int3(2, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftX), int3(3, 3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), int3(2, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX), int3(2, 2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int3(0, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY), int3(3, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int3(0, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightX), int3(3, 2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightY), int3(0, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int3(3, 1, 1));
+        }
+
+        [TestCompiler]
+        public static void int2_shuffle_result_4()
+        {
+            int2 a = int2(0, 1);
+            int2 b = int2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX), int4(0, 0, 1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(2, 1, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX), int4(3, 2, 3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), int4(2, 0, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightX), int4(0, 3, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftY), int4(3, 0, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftX), int4(2, 2, 3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(2, 2, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX, ShuffleComponent.LeftY), int4(0, 1, 2, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightY), int4(2, 1, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftY), int4(3, 3, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int4(2, 2, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), int4(3, 0, 0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), int4(2, 2, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(0, 3, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), int4(2, 0, 0, 0));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e48561bf3abca7029425b31203256201447f3a47
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a60a1141ea2c3bc49b14be2842a73f00
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5ef767911d9f0c840eba4334cdcf95b6785d945a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs
@@ -0,0 +1,1234 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt2x2
+    {
+        [TestCompiler]
+        public static void int2x2_zero()
+        {
+            TestUtils.AreEqual(int2x2.zero.c0.x, 0);
+            TestUtils.AreEqual(int2x2.zero.c0.y, 0);
+            TestUtils.AreEqual(int2x2.zero.c1.x, 0);
+            TestUtils.AreEqual(int2x2.zero.c1.y, 0);
+        }
+
+        [TestCompiler]
+        public static void int2x2_identity()
+        {
+            TestUtils.AreEqual(int2x2.identity.c0.x, 1);
+            TestUtils.AreEqual(int2x2.identity.c0.y, 0);
+            TestUtils.AreEqual(int2x2.identity.c1.x, 0);
+            TestUtils.AreEqual(int2x2.identity.c1.y, 1);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_equal_wide_wide()
+        {
+            int2x2 a0 = int2x2(790229414, 970783976, 1428432738, 1578747135);
+            int2x2 b0 = int2x2(612337669, 1214209108, 2120643427, 295461214);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x2 a1 = int2x2(1733797753, 2001507228, 1446876437, 1777406370);
+            int2x2 b1 = int2x2(1510890331, 1893316566, 921816149, 1834958575);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x2 a2 = int2x2(1426387268, 1809275021, 1843770816, 1172185222);
+            int2x2 b2 = int2x2(1482011863, 2062852792, 226398742, 770290735);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x2 a3 = int2x2(1469608940, 869874758, 458603090, 581282460);
+            int2x2 b3 = int2x2(36812057, 543224481, 1565350150, 1909926604);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_equal_wide_scalar()
+        {
+            int2x2 a0 = int2x2(1211464300, 1921862607, 508076684, 1249127920);
+            int b0 = (746972502);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x2 a1 = int2x2(1394594555, 1733655277, 1884008277, 1682018538);
+            int b1 = (746862310);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x2 a2 = int2x2(795585660, 927605411, 672785749, 1465584610);
+            int b2 = (936027116);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x2 a3 = int2x2(585324157, 969511077, 442746747, 1772925698);
+            int b3 = (404448210);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int2x2 b0 = int2x2(233855098, 924242519, 1402948791, 601381975);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (2120518068);
+            int2x2 b1 = int2x2(629187703, 1971977031, 47183124, 1061805787);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (1009011238);
+            int2x2 b2 = int2x2(312511148, 1460673064, 737210539, 1737844479);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1892405453);
+            int2x2 b3 = int2x2(2133024000, 455818693, 2003197687, 1276241219);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_not_equal_wide_wide()
+        {
+            int2x2 a0 = int2x2(1660932106, 982847023, 97046264, 1739517447);
+            int2x2 b0 = int2x2(107139049, 75478496, 2055495054, 358586687);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x2 a1 = int2x2(1253499180, 1830584069, 1841470429, 1397841646);
+            int2x2 b1 = int2x2(942338347, 111564990, 113811950, 948912488);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x2 a2 = int2x2(1770890135, 1906548631, 169082967, 2099271786);
+            int2x2 b2 = int2x2(1080084121, 1400504872, 1032134499, 1061123400);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x2 a3 = int2x2(1909317609, 46519139, 1433204003, 931492669);
+            int2x2 b3 = int2x2(221862069, 858950046, 989094643, 2023070999);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_not_equal_wide_scalar()
+        {
+            int2x2 a0 = int2x2(747758183, 1033001286, 1439973882, 2138928797);
+            int b0 = (248693828);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x2 a1 = int2x2(1197845089, 950170763, 238704450, 2105962247);
+            int b1 = (1432672459);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x2 a2 = int2x2(727205263, 276313906, 2126300423, 791998981);
+            int b2 = (1640688041);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x2 a3 = int2x2(2035077187, 1412347883, 1622176923, 768370497);
+            int b3 = (1171827730);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int2x2 b0 = int2x2(2037494727, 1989050616, 48833929, 1897435904);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (514354517);
+            int2x2 b1 = int2x2(1783749164, 364694471, 754315072, 124108032);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (1512967900);
+            int2x2 b2 = int2x2(1178825850, 1854793298, 50286949, 2100802631);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1640811853);
+            int2x2 b3 = int2x2(82110247, 472172806, 266984506, 2003668365);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_wide_wide()
+        {
+            int2x2 a0 = int2x2(1182186063, 415538999, 1667335818, 1566618442);
+            int2x2 b0 = int2x2(524633529, 1032195686, 760723389, 1505751409);
+            bool2x2 r0 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x2 a1 = int2x2(1166180837, 639095188, 1080836365, 771119973);
+            int2x2 b1 = int2x2(431962172, 1287906509, 1560084663, 1450178202);
+            bool2x2 r1 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x2 a2 = int2x2(928263233, 789225474, 665243110, 1003542034);
+            int2x2 b2 = int2x2(2066166337, 1107069023, 1640077524, 2103263105);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x2 a3 = int2x2(1032480172, 1961336172, 923379558, 21210619);
+            int2x2 b3 = int2x2(684229139, 1234033624, 1278743281, 1953079347);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_wide_scalar()
+        {
+            int2x2 a0 = int2x2(608447185, 818840405, 869219329, 2080125385);
+            int b0 = (1491216667);
+            bool2x2 r0 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x2 a1 = int2x2(1214500548, 1667165786, 1615392341, 840091491);
+            int b1 = (1361741203);
+            bool2x2 r1 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x2 a2 = int2x2(469591900, 315321650, 930950514, 1100560246);
+            int b2 = (1247103789);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x2 a3 = int2x2(933855388, 1127696709, 1286331950, 380753337);
+            int b3 = (908563901);
+            bool2x2 r3 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int2x2 b0 = int2x2(282703327, 14370648, 1862117300, 1304793311);
+            bool2x2 r0 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (826073259);
+            int2x2 b1 = int2x2(988910157, 445132446, 1139670255, 111349251);
+            bool2x2 r1 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1102440676);
+            int2x2 b2 = int2x2(112183144, 1594415311, 1890019295, 2098715503);
+            bool2x2 r2 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (608933527);
+            int2x2 b3 = int2x2(183989010, 1596056507, 1027318999, 146281093);
+            bool2x2 r3 = bool2x2(false, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_wide_wide()
+        {
+            int2x2 a0 = int2x2(592884447, 2133928932, 918957182, 1284069471);
+            int2x2 b0 = int2x2(138737040, 192863971, 1700841444, 1044631301);
+            bool2x2 r0 = bool2x2(true, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x2 a1 = int2x2(194584707, 739120780, 241654068, 1340158550);
+            int2x2 b1 = int2x2(1391589821, 730837695, 253553987, 2078872742);
+            bool2x2 r1 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x2 a2 = int2x2(2099542537, 1182623667, 1399607274, 789301637);
+            int2x2 b2 = int2x2(910845808, 976047676, 202633078, 1223618940);
+            bool2x2 r2 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x2 a3 = int2x2(180400925, 594688333, 1877031463, 1360073500);
+            int2x2 b3 = int2x2(641600530, 1830470354, 1570701388, 1104256103);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_wide_scalar()
+        {
+            int2x2 a0 = int2x2(1097138316, 211763648, 1883002501, 56406996);
+            int b0 = (438688675);
+            bool2x2 r0 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x2 a1 = int2x2(43662641, 1437755186, 1219010035, 2125058448);
+            int b1 = (1923456111);
+            bool2x2 r1 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x2 a2 = int2x2(304028799, 48044515, 711945018, 1035679270);
+            int b2 = (893125636);
+            bool2x2 r2 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x2 a3 = int2x2(577943770, 1016617211, 2063134811, 1577403353);
+            int b3 = (572743717);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int2x2 b0 = int2x2(599356784, 185671342, 1932327391, 2025591013);
+            bool2x2 r0 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1257191721);
+            int2x2 b1 = int2x2(1312388500, 1443698859, 779217735, 691047512);
+            bool2x2 r1 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (741776730);
+            int2x2 b2 = int2x2(732565983, 668302204, 1556466996, 858599525);
+            bool2x2 r2 = bool2x2(true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (1896917159);
+            int2x2 b3 = int2x2(701542098, 1052151621, 1023307544, 1435392907);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_equal_wide_wide()
+        {
+            int2x2 a0 = int2x2(1577248162, 2043073061, 1688380407, 176431985);
+            int2x2 b0 = int2x2(903445031, 2108974565, 210822256, 1281704747);
+            bool2x2 r0 = bool2x2(false, true, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x2 a1 = int2x2(223299035, 1502802140, 1691709825, 386789394);
+            int2x2 b1 = int2x2(453681718, 66138830, 1229799377, 1620922595);
+            bool2x2 r1 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x2 a2 = int2x2(117182003, 1665770435, 1958490731, 420032601);
+            int2x2 b2 = int2x2(1715833766, 1366430432, 13102000, 46919981);
+            bool2x2 r2 = bool2x2(true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x2 a3 = int2x2(1251092689, 2011681765, 749743684, 183784440);
+            int2x2 b3 = int2x2(486470891, 1709514236, 2145785285, 854254454);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_equal_wide_scalar()
+        {
+            int2x2 a0 = int2x2(1722165358, 1219858357, 860410743, 411099660);
+            int b0 = (1688048545);
+            bool2x2 r0 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x2 a1 = int2x2(348104022, 212084836, 58924407, 1459242706);
+            int b1 = (1963256951);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x2 a2 = int2x2(1745758438, 262559763, 690091301, 1806172431);
+            int b2 = (532949158);
+            bool2x2 r2 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x2 a3 = int2x2(2091514001, 1617221948, 2017733017, 804204255);
+            int b3 = (1857173043);
+            bool2x2 r3 = bool2x2(false, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int2x2 b0 = int2x2(1181030049, 1787703989, 1729760948, 1816537388);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1359786460);
+            int2x2 b1 = int2x2(874999193, 1678863148, 1711365839, 762067160);
+            bool2x2 r1 = bool2x2(false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (11953554);
+            int2x2 b2 = int2x2(1131583906, 1175393186, 1293698493, 48893340);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (66196247);
+            int2x2 b3 = int2x2(1958607116, 1576473309, 861890786, 478252419);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_equal_wide_wide()
+        {
+            int2x2 a0 = int2x2(263000030, 744235661, 1893760267, 237248);
+            int2x2 b0 = int2x2(1395535146, 1178373944, 1237373760, 1364855321);
+            bool2x2 r0 = bool2x2(false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x2 a1 = int2x2(1062370984, 1676977687, 816766880, 1089431546);
+            int2x2 b1 = int2x2(600811864, 362060472, 290870624, 1839067862);
+            bool2x2 r1 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x2 a2 = int2x2(1394493730, 1176473380, 1193988637, 1703862455);
+            int2x2 b2 = int2x2(396958580, 1336888643, 1019684398, 1697684196);
+            bool2x2 r2 = bool2x2(true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x2 a3 = int2x2(1806186947, 1253571980, 589397635, 1951842887);
+            int2x2 b3 = int2x2(1227300220, 2044269675, 1898323839, 874509380);
+            bool2x2 r3 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_equal_wide_scalar()
+        {
+            int2x2 a0 = int2x2(2112791350, 1043657935, 101764761, 1529909067);
+            int b0 = (1470533736);
+            bool2x2 r0 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x2 a1 = int2x2(556026890, 1186600258, 815093894, 609211196);
+            int b1 = (281734132);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x2 a2 = int2x2(1604309397, 244604867, 1419295004, 471843809);
+            int b2 = (829548642);
+            bool2x2 r2 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x2 a3 = int2x2(1819986195, 1646290021, 196833647, 1596738181);
+            int b3 = (1460027917);
+            bool2x2 r3 = bool2x2(true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int2x2 b0 = int2x2(1503244746, 861711266, 817773856, 925984572);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (571221723);
+            int2x2 b1 = int2x2(683686810, 118252990, 1653952090, 1240253990);
+            bool2x2 r1 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (1947039008);
+            int2x2 b2 = int2x2(1869136019, 152012637, 1214546726, 917376832);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (303549425);
+            int2x2 b3 = int2x2(2111728811, 945321577, 173706579, 625318949);
+            bool2x2 r3 = bool2x2(false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_add_wide_wide()
+        {
+            int2x2 a0 = int2x2(2049228671, 1658660009, 491719392, 937013355);
+            int2x2 b0 = int2x2(2088751567, 645762023, 306868786, 4360271);
+            int2x2 r0 = int2x2(-156987058, -1990545264, 798588178, 941373626);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x2 a1 = int2x2(81108663, 1063894558, 86954702, 843159721);
+            int2x2 b1 = int2x2(506047997, 2094559874, 1634712736, 1601474440);
+            int2x2 r1 = int2x2(587156660, -1136512864, 1721667438, -1850333135);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x2 a2 = int2x2(698977704, 192867135, 1683407172, 137301303);
+            int2x2 b2 = int2x2(1586485231, 908746788, 1812370320, 1247342357);
+            int2x2 r2 = int2x2(-2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x2 a3 = int2x2(2103582820, 526139155, 447937230, 2127411006);
+            int2x2 b3 = int2x2(2043773873, 223363428, 175115707, 985928617);
+            int2x2 r3 = int2x2(-147610603, 749502583, 623052937, -1181627673);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_add_wide_scalar()
+        {
+            int2x2 a0 = int2x2(2038218457, 134923711, 875689667, 1338884463);
+            int b0 = (2124409227);
+            int2x2 r0 = int2x2(-132339612, -2035634358, -1294868402, -831673606);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x2 a1 = int2x2(997710928, 1067888129, 70433301, 2003021861);
+            int b1 = (340490871);
+            int2x2 r1 = int2x2(1338201799, 1408379000, 410924172, -1951454564);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x2 a2 = int2x2(1635971971, 85446202, 1068152966, 1239387100);
+            int b2 = (1160398286);
+            int2x2 r2 = int2x2(-1498597039, 1245844488, -2066416044, -1895181910);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x2 a3 = int2x2(1497676888, 1095438654, 756559204, 1818718931);
+            int b3 = (1727477485);
+            int2x2 r3 = int2x2(-1069812923, -1472051157, -1810930607, -748770880);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int2x2 b0 = int2x2(519908870, 851424292, 328314822, 135622204);
+            int2x2 r0 = int2x2(911000948, 1242516370, 719406900, 526714282);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (740923360);
+            int2x2 b1 = int2x2(655394201, 1451896269, 1781697072, 996031825);
+            int2x2 r1 = int2x2(1396317561, -2102147667, -1772346864, 1736955185);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1557774949);
+            int2x2 b2 = int2x2(779774940, 1111541302, 783046445, 1130163944);
+            int2x2 r2 = int2x2(-1957417407, -1625651045, -1954145902, -1607028403);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (288279584);
+            int2x2 b3 = int2x2(1397683861, 1636583489, 673263339, 1469300874);
+            int2x2 r3 = int2x2(1685963445, 1924863073, 961542923, 1757580458);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_sub_wide_wide()
+        {
+            int2x2 a0 = int2x2(1353441118, 797269833, 659988112, 56022121);
+            int2x2 b0 = int2x2(1332656812, 1827794007, 972557431, 2078233689);
+            int2x2 r0 = int2x2(20784306, -1030524174, -312569319, -2022211568);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x2 a1 = int2x2(365847472, 2062899435, 1380988474, 799885138);
+            int2x2 b1 = int2x2(1508184327, 1372307701, 810327977, 936799885);
+            int2x2 r1 = int2x2(-1142336855, 690591734, 570660497, -136914747);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x2 a2 = int2x2(1306058185, 579775276, 1239163824, 344591081);
+            int2x2 b2 = int2x2(71562303, 1418723328, 1971342989, 1226053395);
+            int2x2 r2 = int2x2(1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x2 a3 = int2x2(86359575, 1049709943, 721529513, 1767221271);
+            int2x2 b3 = int2x2(136565478, 1979903295, 600719425, 837912956);
+            int2x2 r3 = int2x2(-50205903, -930193352, 120810088, 929308315);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_sub_wide_scalar()
+        {
+            int2x2 a0 = int2x2(1176369558, 1934521195, 309452150, 1417634074);
+            int b0 = (462232403);
+            int2x2 r0 = int2x2(714137155, 1472288792, -152780253, 955401671);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x2 a1 = int2x2(108910717, 1502312334, 1451794815, 281174200);
+            int b1 = (1306356714);
+            int2x2 r1 = int2x2(-1197445997, 195955620, 145438101, -1025182514);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x2 a2 = int2x2(87530840, 2041593336, 557239990, 1119051448);
+            int b2 = (1913724431);
+            int2x2 r2 = int2x2(-1826193591, 127868905, -1356484441, -794672983);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x2 a3 = int2x2(1590376732, 816382635, 815920639, 1829033117);
+            int b3 = (819090189);
+            int2x2 r3 = int2x2(771286543, -2707554, -3169550, 1009942928);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int2x2 b0 = int2x2(2022393810, 1612688515, 496689713, 887037586);
+            int2x2 r0 = int2x2(-330859405, 78845890, 1194844692, 804496819);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (2097630964);
+            int2x2 b1 = int2x2(374934538, 939035482, 935242277, 1789300421);
+            int2x2 r1 = int2x2(1722696426, 1158595482, 1162388687, 308330543);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (264712893);
+            int2x2 b2 = int2x2(1231856067, 1818112748, 1428436109, 1258745460);
+            int2x2 r2 = int2x2(-967143174, -1553399855, -1163723216, -994032567);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1077380396);
+            int2x2 b3 = int2x2(1330722719, 518111829, 967128529, 344666254);
+            int2x2 r3 = int2x2(-253342323, 559268567, 110251867, 732714142);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mul_wide_wide()
+        {
+            int2x2 a0 = int2x2(245827027, 208934650, 1019478917, 568231809);
+            int2x2 b0 = int2x2(759663997, 350129201, 477450108, 1635735015);
+            int2x2 r0 = int2x2(-632811769, 1402281434, 332447596, -1932977561);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x2 a1 = int2x2(877289039, 1585782440, 2111178729, 1186019069);
+            int2x2 b1 = int2x2(388710278, 757722665, 1509388321, 1841703980);
+            int2x2 r1 = int2x2(-1670918566, 1455036648, 2128344329, -594088068);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x2 a2 = int2x2(571481445, 1570087048, 629447153, 619383734);
+            int2x2 b2 = int2x2(1826369331, 1524322467, 1605207974, 428419155);
+            int2x2 r2 = int2x2(-1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x2 a3 = int2x2(2055121568, 700402816, 263414349, 187830569);
+            int2x2 b3 = int2x2(1460605791, 1968043860, 771161742, 2037340417);
+            int2x2 r3 = int2x2(990589280, -938173952, -1341723466, 1156600361);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mul_wide_scalar()
+        {
+            int2x2 a0 = int2x2(1762033447, 465343930, 1570757881, 1326409563);
+            int b0 = (1476837906);
+            int2x2 r0 = int2x2(-1313177922, 1326807828, -2138555518, -276153754);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x2 a1 = int2x2(1824319147, 72749215, 154616909, 975743632);
+            int b1 = (1356578909);
+            int2x2 r1 = int2x2(-236385249, 130042307, 1244434425, -1981680048);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x2 a2 = int2x2(573770299, 971327747, 1818877398, 1324050764);
+            int b2 = (1958912969);
+            int2x2 r2 = int2x2(-699623085, 583613531, -1685426426, 377032876);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x2 a3 = int2x2(660611671, 391009467, 1186856590, 890343818);
+            int b3 = (1279757657);
+            int2x2 r3 = int2x2(-42542273, 1120105475, -22825634, 1972017914);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int2x2 b0 = int2x2(1764461774, 657072478, 1459784358, 1610646683);
+            int2x2 r0 = int2x2(-950398648, -102049016, 1260585960, 1158730452);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1632058826);
+            int2x2 b1 = int2x2(868441654, 1408757883, 335917146, 2105124483);
+            int2x2 r1 = int2x2(-57330532, -1559359474, 712546564, -805332386);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1178393968);
+            int2x2 b2 = int2x2(1963904348, 1409533767, 243286231, 1336308795);
+            int2x2 r2 = int2x2(1196573760, 592673296, 209320208, -352466736);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (517963367);
+            int2x2 b3 = int2x2(1733623488, 459880225, 994616533, 1420531535);
+            int2x2 r3 = int2x2(-774570176, -1271501753, 652617651, -1789672759);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_div_wide_wide()
+        {
+            int2x2 a0 = int2x2(1590198532, 507812502, 126627032, 1058247011);
+            int2x2 b0 = int2x2(1434703236, 911965201, 390415521, 128746927);
+            int2x2 r0 = int2x2(1, 0, 0, 8);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x2 a1 = int2x2(427387861, 290676154, 1829594484, 1127868739);
+            int2x2 b1 = int2x2(525835375, 816946613, 878264647, 146789678);
+            int2x2 r1 = int2x2(0, 0, 2, 7);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x2 a2 = int2x2(499016351, 1341209632, 134906097, 785470242);
+            int2x2 b2 = int2x2(2089524057, 254213018, 1916850021, 1737806518);
+            int2x2 r2 = int2x2(0, 5, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x2 a3 = int2x2(788249865, 1099825433, 1552968283, 1822367139);
+            int2x2 b3 = int2x2(1906634983, 437754923, 825037958, 902508708);
+            int2x2 r3 = int2x2(0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_div_wide_scalar()
+        {
+            int2x2 a0 = int2x2(560951562, 1218680769, 375341724, 1613542090);
+            int b0 = (947861580);
+            int2x2 r0 = int2x2(0, 1, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x2 a1 = int2x2(1919409166, 1349573078, 524526253, 341995568);
+            int b1 = (1397425408);
+            int2x2 r1 = int2x2(1, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x2 a2 = int2x2(495895326, 1676971657, 2131487088, 2105094094);
+            int b2 = (1515313790);
+            int2x2 r2 = int2x2(0, 1, 1, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x2 a3 = int2x2(1017891310, 1646044372, 1447236569, 107215658);
+            int b3 = (542666029);
+            int2x2 r3 = int2x2(1, 3, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int2x2 b0 = int2x2(187325733, 1594107378, 2016183849, 1589343709);
+            int2x2 r0 = int2x2(6, 0, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (388768753);
+            int2x2 b1 = int2x2(1417077283, 1773486938, 1154044032, 81831373);
+            int2x2 r1 = int2x2(0, 0, 0, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1476877645);
+            int2x2 b2 = int2x2(653688843, 45756703, 631027637, 396671391);
+            int2x2 r2 = int2x2(2, 32, 2, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (784365696);
+            int2x2 b3 = int2x2(1250594097, 1818363859, 1653451772, 270557729);
+            int2x2 r3 = int2x2(0, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mod_wide_wide()
+        {
+            int2x2 a0 = int2x2(146150818, 1846543305, 1071447756, 308965362);
+            int2x2 b0 = int2x2(983050390, 771341152, 942375212, 367361754);
+            int2x2 r0 = int2x2(146150818, 303861001, 129072544, 308965362);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x2 a1 = int2x2(659881575, 1002365460, 861198439, 1510617532);
+            int2x2 b1 = int2x2(749500619, 750718852, 2095151755, 88438806);
+            int2x2 r1 = int2x2(659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x2 a2 = int2x2(778525078, 1458458044, 101987897, 1249565173);
+            int2x2 b2 = int2x2(769227442, 647214624, 1026513788, 1544950956);
+            int2x2 r2 = int2x2(9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x2 a3 = int2x2(938026607, 1692541775, 1518877124, 1806965510);
+            int2x2 b3 = int2x2(160166322, 1099108075, 1158422232, 1798905209);
+            int2x2 r3 = int2x2(137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mod_wide_scalar()
+        {
+            int2x2 a0 = int2x2(164800505, 1062177828, 1898749675, 1701653318);
+            int b0 = (883951171);
+            int2x2 r0 = int2x2(164800505, 178226657, 130847333, 817702147);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x2 a1 = int2x2(820393245, 128329633, 1464010899, 896587769);
+            int b1 = (19002208);
+            int2x2 r1 = int2x2(3298301, 14316385, 840883, 3483993);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x2 a2 = int2x2(405208598, 959236935, 712321026, 172564850);
+            int b2 = (1982762194);
+            int2x2 r2 = int2x2(405208598, 959236935, 712321026, 172564850);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x2 a3 = int2x2(1540068445, 1607489717, 165478511, 647846716);
+            int b3 = (1085897743);
+            int2x2 r3 = int2x2(454170702, 521591974, 165478511, 647846716);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int2x2 b0 = int2x2(740000543, 1556450291, 1104736385, 437976569);
+            int2x2 r0 = int2x2(242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1911837205);
+            int2x2 b1 = int2x2(1507212038, 1906405167, 247693265, 293460573);
+            int2x2 r1 = int2x2(404625167, 5432038, 177984350, 151073767);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (1495295166);
+            int2x2 b2 = int2x2(873323603, 530681233, 1298102643, 2057984657);
+            int2x2 r2 = int2x2(621971563, 433932700, 197192523, 1495295166);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1000742091);
+            int2x2 b3 = int2x2(1461372131, 1859742342, 797184687, 821888842);
+            int2x2 r3 = int2x2(1000742091, 1000742091, 203557404, 178853249);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_plus()
+        {
+            int2x2 a0 = int2x2(1643476803, 907898539, 379615839, 1140483021);
+            int2x2 r0 = int2x2(1643476803, 907898539, 379615839, 1140483021);
+            TestUtils.AreEqual(+a0, r0);
+
+            int2x2 a1 = int2x2(1735287433, 1472881565, 339091479, 401565897);
+            int2x2 r1 = int2x2(1735287433, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a1, r1);
+
+            int2x2 a2 = int2x2(1287765427, 174532915, 1864850812, 1566098441);
+            int2x2 r2 = int2x2(1287765427, 174532915, 1864850812, 1566098441);
+            TestUtils.AreEqual(+a2, r2);
+
+            int2x2 a3 = int2x2(1145639744, 2049663954, 1723005749, 409076474);
+            int2x2 r3 = int2x2(1145639744, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_neg()
+        {
+            int2x2 a0 = int2x2(1955022112, 662160019, 370300775, 2141283773);
+            int2x2 r0 = int2x2(-1955022112, -662160019, -370300775, -2141283773);
+            TestUtils.AreEqual(-a0, r0);
+
+            int2x2 a1 = int2x2(1004505619, 33894270, 505708349, 1115028238);
+            int2x2 r1 = int2x2(-1004505619, -33894270, -505708349, -1115028238);
+            TestUtils.AreEqual(-a1, r1);
+
+            int2x2 a2 = int2x2(1636274969, 1542206286, 213087293, 243937487);
+            int2x2 r2 = int2x2(-1636274969, -1542206286, -213087293, -243937487);
+            TestUtils.AreEqual(-a2, r2);
+
+            int2x2 a3 = int2x2(341522275, 574159094, 1687250035, 2057919693);
+            int2x2 r3 = int2x2(-341522275, -574159094, -1687250035, -2057919693);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_prefix_inc()
+        {
+            int2x2 a0 = int2x2(864455342, 2035793213, 1275443862, 971919915);
+            int2x2 r0 = int2x2(864455343, 2035793214, 1275443863, 971919916);
+            TestUtils.AreEqual(++a0, r0);
+
+            int2x2 a1 = int2x2(411610189, 395072276, 115573442, 913293639);
+            int2x2 r1 = int2x2(411610190, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a1, r1);
+
+            int2x2 a2 = int2x2(432884105, 1385544935, 1835605516, 831396561);
+            int2x2 r2 = int2x2(432884106, 1385544936, 1835605517, 831396562);
+            TestUtils.AreEqual(++a2, r2);
+
+            int2x2 a3 = int2x2(388229350, 1786514683, 993189311, 752093909);
+            int2x2 r3 = int2x2(388229351, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_postfix_inc()
+        {
+            int2x2 a0 = int2x2(1751003569, 2063707595, 1500486291, 969189211);
+            int2x2 r0 = int2x2(1751003569, 2063707595, 1500486291, 969189211);
+            TestUtils.AreEqual(a0++, r0);
+
+            int2x2 a1 = int2x2(1007848192, 1643023524, 1190630527, 1396179607);
+            int2x2 r1 = int2x2(1007848192, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a1++, r1);
+
+            int2x2 a2 = int2x2(708474528, 1524860667, 1408994706, 375284401);
+            int2x2 r2 = int2x2(708474528, 1524860667, 1408994706, 375284401);
+            TestUtils.AreEqual(a2++, r2);
+
+            int2x2 a3 = int2x2(1580130369, 717006530, 506142468, 732199129);
+            int2x2 r3 = int2x2(1580130369, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_prefix_dec()
+        {
+            int2x2 a0 = int2x2(200904609, 871077500, 968578728, 638967721);
+            int2x2 r0 = int2x2(200904608, 871077499, 968578727, 638967720);
+            TestUtils.AreEqual(--a0, r0);
+
+            int2x2 a1 = int2x2(1995396216, 1782514098, 1589827826, 1434377580);
+            int2x2 r1 = int2x2(1995396215, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a1, r1);
+
+            int2x2 a2 = int2x2(596759698, 1758478358, 1914114460, 71237375);
+            int2x2 r2 = int2x2(596759697, 1758478357, 1914114459, 71237374);
+            TestUtils.AreEqual(--a2, r2);
+
+            int2x2 a3 = int2x2(389120307, 1310293956, 356565557, 18299409);
+            int2x2 r3 = int2x2(389120306, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_postfix_dec()
+        {
+            int2x2 a0 = int2x2(283970262, 1109329936, 1073216143, 649439137);
+            int2x2 r0 = int2x2(283970262, 1109329936, 1073216143, 649439137);
+            TestUtils.AreEqual(a0--, r0);
+
+            int2x2 a1 = int2x2(1932646215, 484207852, 524156737, 691209285);
+            int2x2 r1 = int2x2(1932646215, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a1--, r1);
+
+            int2x2 a2 = int2x2(2017728859, 377162390, 526366486, 1504625034);
+            int2x2 r2 = int2x2(2017728859, 377162390, 526366486, 1504625034);
+            TestUtils.AreEqual(a2--, r2);
+
+            int2x2 a3 = int2x2(590919177, 1867810045, 2095777993, 670715645);
+            int2x2 r3 = int2x2(590919177, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_and_wide_wide()
+        {
+            int2x2 a0 = int2x2(779935043, 1097962163, 1939593304, 800599247);
+            int2x2 b0 = int2x2(307705143, 1710882162, 866836769, 532490608);
+            int2x2 r0 = int2x2(39064835, 1097961522, 864731136, 263727168);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x2 a1 = int2x2(952140918, 782792558, 1608557706, 396446406);
+            int2x2 b1 = int2x2(679371720, 1794035877, 1439832202, 519529812);
+            int2x2 r1 = int2x2(675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x2 a2 = int2x2(2039894114, 1286974642, 442394124, 1759739564);
+            int2x2 b2 = int2x2(23633139, 1209152681, 646737179, 1255867027);
+            int2x2 r2 = int2x2(16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x2 a3 = int2x2(233435438, 665207770, 1942050241, 1022352952);
+            int2x2 b3 = int2x2(1900854122, 413173763, 1409138251, 2087190272);
+            int2x2 r3 = int2x2(21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_and_wide_scalar()
+        {
+            int2x2 a0 = int2x2(443615469, 490057985, 2042441263, 1524760558);
+            int b0 = (93423598);
+            int2x2 r0 = int2x2(1114348, 85033216, 26281518, 8488942);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x2 a1 = int2x2(1405175110, 1941875181, 1236735839, 1365509729);
+            int b1 = (510212004);
+            int2x2 r1 = int2x2(306251012, 304619940, 136386308, 274728480);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x2 a2 = int2x2(428270198, 650270920, 1249238550, 814629680);
+            int b2 = (607982857);
+            int2x2 r2 = int2x2(262144, 603983880, 3478528, 537657600);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x2 a3 = int2x2(1862276471, 861733033, 1408932942, 957693145);
+            int b3 = (143502472);
+            int2x2 r3 = int2x2(134218752, 852104, 8948744, 134556808);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int2x2 b0 = int2x2(420346723, 562416448, 1393127318, 1560699552);
+            int2x2 r0 = int2x2(547170, 18752, 1074284806, 1140867104);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (851218057);
+            int2x2 b1 = int2x2(703880958, 1159378889, 2031211279, 1089518981);
+            int2x2 r1 = int2x2(548671112, 1607305, 806388233, 11570305);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (270607307);
+            int2x2 b2 = int2x2(1349288930, 520199596, 1763483957, 1248975349);
+            int2x2 r2 = int2x2(270533570, 268501384, 8449, 2163137);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (236938635);
+            int2x2 b3 = int2x2(185023291, 1085233038, 1845693112, 946052961);
+            int2x2 r3 = int2x2(168239371, 1000842, 235077768, 134415617);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_or_wide_wide()
+        {
+            int2x2 a0 = int2x2(1731159103, 659068416, 382702471, 1821032196);
+            int2x2 b0 = int2x2(1583847161, 692672727, 1161585489, 1756207130);
+            int2x2 r0 = int2x2(2138044159, 793370327, 1476391895, 1823457054);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x2 a1 = int2x2(1565773438, 1004000514, 948501377, 600951835);
+            int2x2 b1 = int2x2(1321374429, 1287357212, 2075767170, 1273513430);
+            int2x2 r1 = int2x2(1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x2 a2 = int2x2(669346222, 396691477, 2108560248, 2117522137);
+            int2x2 b2 = int2x2(1610830169, 1316929125, 511625048, 573925879);
+            int2x2 r2 = int2x2(1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x2 a3 = int2x2(330307355, 818676817, 1774459567, 1117506257);
+            int2x2 b3 = int2x2(1502255628, 1841676448, 1682928938, 1115131952);
+            int2x2 r3 = int2x2(1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_or_wide_scalar()
+        {
+            int2x2 a0 = int2x2(961259683, 471103264, 1733389229, 1591585258);
+            int b0 = (1666102508);
+            int2x2 r0 = int2x2(2068823279, 2136930284, 1734344685, 2145369582);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x2 a1 = int2x2(386953869, 1048929715, 1814263250, 860336789);
+            int b1 = (1148351449);
+            int2x2 r1 = int2x2(1467118557, 2130147323, 1819506651, 2004349917);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x2 a2 = int2x2(1637162093, 774029856, 879300408, 1179087439);
+            int b2 = (1227888278);
+            int2x2 r2 = int2x2(1773477631, 1865602742, 2105089982, 1333229279);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x2 a3 = int2x2(797240690, 46921989, 1980838747, 284225881);
+            int b3 = (1977614655);
+            int2x2 r3 = int2x2(2145709439, 2011953471, 2012296063, 1978724735);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int2x2 b0 = int2x2(1212928242, 1614462616, 936937728, 764766995);
+            int2x2 r0 = int2x2(1213978111, 1752940445, 2145094925, 1842867999);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (306352095);
+            int2x2 b1 = int2x2(574719481, 1283571271, 2109131012, 979469710);
+            int2x2 r1 = int2x2(843288575, 1589886943, 2146881503, 979603423);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (1348323481);
+            int2x2 b2 = int2x2(1407542578, 697517649, 1059093741, 627815046);
+            int2x2 r2 = int2x2(1409150395, 2044710617, 2138963197, 1971321503);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (418822515);
+            int2x2 b3 = int2x2(83214352, 424663473, 447949225, 527022375);
+            int2x2 r3 = int2x2(486013299, 436206067, 452442619, 536852855);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_xor_wide_wide()
+        {
+            int2x2 a0 = int2x2(1556324760, 207002929, 1843444873, 1632079131);
+            int2x2 b0 = int2x2(1054997548, 1523759632, 251164872, 110472397);
+            int2x2 r0 = int2x2(1646419380, 1451501345, 1662567489, 1741824470);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x2 a1 = int2x2(1460334334, 1607815585, 220623650, 38668553);
+            int2x2 b1 = int2x2(384031112, 1109163205, 535118981, 179106262);
+            int2x2 r1 = int2x2(1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x2 a2 = int2x2(47193340, 643663548, 1371932564, 94957188);
+            int2x2 b2 = int2x2(1523031711, 1713313372, 1294118730, 520360641);
+            int2x2 r2 = int2x2(1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x2 a3 = int2x2(700973621, 370621508, 2087573076, 351476570);
+            int2x2 b3 = int2x2(1040688781, 1020757245, 1143954843, 1281933464);
+            int2x2 r3 = int2x2(399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_xor_wide_scalar()
+        {
+            int2x2 a0 = int2x2(2124666952, 177397845, 574879617, 1937385541);
+            int b0 = (493665894);
+            int2x2 r0 = int2x2(1674536494, 402546227, 1060063719, 1846973987);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x2 a1 = int2x2(1136545648, 535061373, 289301586, 1305234431);
+            int b1 = (213863690);
+            int2x2 r1 = int2x2(1325466234, 324742775, 495003992, 1098057461);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x2 a2 = int2x2(353786540, 1267729267, 125659640, 1315625690);
+            int b2 = (1308626970);
+            int2x2 r2 = int2x2(1528187574, 93328233, 1232959970, 6998720);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x2 a3 = int2x2(1730088797, 375757978, 491079274, 191750702);
+            int b3 = (116862046);
+            int2x2 r3 = int2x2(1642603267, 278048964, 464677428, 228249200);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int2x2 b0 = int2x2(1077599928, 884741329, 212164516, 1585020328);
+            int2x2 r0 = int2x2(217506340, 2020616269, 1080648504, 313868596);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (152985454);
+            int2x2 b1 = int2x2(1775851275, 1416249064, 1309317737, 1773918217);
+            int2x2 r1 = int2x2(1623656549, 1567908230, 1192543495, 1621460839);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1509843030);
+            int2x2 b2 = int2x2(1206045972, 1154916424, 1947871003, 1774252400);
+            int2x2 r2 = int2x2(505195842, 489209886, 769935181, 809406758);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1946113778);
+            int2x2 b3 = int2x2(1079717492, 290620937, 1382343363, 939045099);
+            int2x2 r3 = int2x2(866416774, 1655558395, 563852337, 1141368345);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_left_shift()
+        {
+            int2x2 a0 = int2x2(197771193, 622182602, 1283988958, 1327917304);
+            int b0 = (1321149625);
+            int2x2 r0 = int2x2(1912602624, -1811939328, -1140850688, -268435456);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int2x2 a1 = int2x2(473415985, 870301196, 2058433484, 1200694230);
+            int b1 = (432425717);
+            int2x2 r1 = int2x2(639631360, -1048576000, 2038431744, 2059403264);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int2x2 a2 = int2x2(1531607705, 1008296534, 1447702302, 1079614371);
+            int b2 = (1360008038);
+            int2x2 r2 = int2x2(-761354688, 106468736, -1836333184, 375843008);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int2x2 a3 = int2x2(35667343, 2045594989, 2077023268, 592678686);
+            int b3 = (1664454606);
+            int2x2 r3 = int2x2(258195456, 1398489088, 923336704, -473464832);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_right_shift()
+        {
+            int2x2 a0 = int2x2(548167301, 1161338299, 1617625829, 1860731847);
+            int b0 = (1266801540);
+            int2x2 r0 = int2x2(34260456, 72583643, 101101614, 116295740);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int2x2 a1 = int2x2(713958715, 770466193, 1265099998, 572763124);
+            int b1 = (196552656);
+            int2x2 r1 = int2x2(10894, 11756, 19303, 8739);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int2x2 a2 = int2x2(506619530, 2031319045, 701927980, 917785020);
+            int b2 = (426807581);
+            int2x2 r2 = int2x2(0, 3, 1, 1);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int2x2 a3 = int2x2(569504877, 1102123711, 334005460, 1624751550);
+            int b3 = (185593382);
+            int2x2 r3 = int2x2(8898513, 17220682, 5218835, 25386742);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x2_operator_bitwise_not()
+        {
+            int2x2 a0 = int2x2(1403358969, 831360921, 2088190243, 976721016);
+            int2x2 r0 = int2x2(-1403358970, -831360922, -2088190244, -976721017);
+            TestUtils.AreEqual(~a0, r0);
+
+            int2x2 a1 = int2x2(878283189, 1935567517, 1420884856, 472965491);
+            int2x2 r1 = int2x2(-878283190, -1935567518, -1420884857, -472965492);
+            TestUtils.AreEqual(~a1, r1);
+
+            int2x2 a2 = int2x2(771711426, 2061524024, 753208488, 2097179283);
+            int2x2 r2 = int2x2(-771711427, -2061524025, -753208489, -2097179284);
+            TestUtils.AreEqual(~a2, r2);
+
+            int2x2 a3 = int2x2(1303022493, 1289372466, 1635981125, 1951018596);
+            int2x2 r3 = int2x2(-1303022494, -1289372467, -1635981126, -1951018597);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7bdf74185159ef47d0bceaf523d5bea2b73340c8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 041eb9518baf7a846bd945a05063b142
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..1b77efe90dad9ff333a8b58a1603d1dade5bbaaa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs
@@ -0,0 +1,1227 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt2x3
+    {
+        [TestCompiler]
+        public static void int2x3_zero()
+        {
+            TestUtils.AreEqual(int2x3.zero.c0.x, 0);
+            TestUtils.AreEqual(int2x3.zero.c0.y, 0);
+            TestUtils.AreEqual(int2x3.zero.c1.x, 0);
+            TestUtils.AreEqual(int2x3.zero.c1.y, 0);
+            TestUtils.AreEqual(int2x3.zero.c2.x, 0);
+            TestUtils.AreEqual(int2x3.zero.c2.y, 0);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_equal_wide_wide()
+        {
+            int2x3 a0 = int2x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228);
+            int2x3 b0 = int2x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x3 a1 = int2x3(1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            int2x3 b1 = int2x3(921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x3 a2 = int2x3(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            int2x3 b2 = int2x3(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x3 a3 = int2x3(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int2x3 b3 = int2x3(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_equal_wide_scalar()
+        {
+            int2x3 a0 = int2x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310);
+            int b0 = (746972502);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x3 a1 = int2x3(1733655277, 1682018538, 795585660, 936027116, 927605411, 672785749);
+            int b1 = (1884008277);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x3 a2 = int2x3(1465584610, 404448210, 969511077, 442746747, 1772925698, 1884034177);
+            int b2 = (585324157);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x3 a3 = int2x3(451512860, 1370577708, 597010220, 1249636005, 211986678, 1305479811);
+            int b3 = (425476075);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int2x3 b0 = int2x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1971977031);
+            int2x3 b1 = int2x3(47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (1737844479);
+            int2x3 b2 = int2x3(1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (559824292);
+            int2x3 b3 = int2x3(1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_not_equal_wide_wide()
+        {
+            int2x3 a0 = int2x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069);
+            int2x3 b0 = int2x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x3 a1 = int2x3(1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            int2x3 b1 = int2x3(113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x3 a2 = int2x3(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            int2x3 b2 = int2x3(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x3 a3 = int2x3(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int2x3 b3 = int2x3(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_not_equal_wide_scalar()
+        {
+            int2x3 a0 = int2x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459);
+            int b0 = (248693828);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x3 a1 = int2x3(950170763, 2105962247, 727205263, 1640688041, 276313906, 2126300423);
+            int b1 = (238704450);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x3 a2 = int2x3(791998981, 1171827730, 1412347883, 1622176923, 768370497, 1072798259);
+            int b2 = (2035077187);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x3 a3 = int2x3(1808712713, 1582645163, 1876273820, 90244766, 30493685, 904014575);
+            int b3 = (1497830076);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int2x3 b0 = int2x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (364694471);
+            int2x3 b1 = int2x3(754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (2100802631);
+            int2x3 b2 = int2x3(1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1041416160);
+            int2x3 b3 = int2x3(356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_wide_wide()
+        {
+            int2x3 a0 = int2x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188);
+            int2x3 b0 = int2x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509);
+            bool2x3 r0 = bool2x3(false, true, false, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x3 a1 = int2x3(1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            int2x3 b1 = int2x3(1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x3 a2 = int2x3(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            int2x3 b2 = int2x3(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool2x3 r2 = bool2x3(false, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x3 a3 = int2x3(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int2x3 b3 = int2x3(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool2x3 r3 = bool2x3(true, true, false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_wide_scalar()
+        {
+            int2x3 a0 = int2x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203);
+            int b0 = (1491216667);
+            bool2x3 r0 = bool2x3(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x3 a1 = int2x3(1667165786, 840091491, 469591900, 1247103789, 315321650, 930950514);
+            int b1 = (1615392341);
+            bool2x3 r1 = bool2x3(false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x3 a2 = int2x3(1100560246, 908563901, 1127696709, 1286331950, 380753337, 971148054);
+            int b2 = (933855388);
+            bool2x3 r2 = bool2x3(false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x3 a3 = int2x3(1827886929, 1579735991, 689044913, 1960894027, 371987110, 867559111);
+            int b3 = (1056649851);
+            bool2x3 r3 = bool2x3(false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int2x3 b0 = int2x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157);
+            bool2x3 r0 = bool2x3(false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (445132446);
+            int2x3 b1 = int2x3(1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295);
+            bool2x3 r1 = bool2x3(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (2098715503);
+            int2x3 b2 = int2x3(608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (874278078);
+            int2x3 b3 = int2x3(1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911);
+            bool2x3 r3 = bool2x3(true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_wide_wide()
+        {
+            int2x3 a0 = int2x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780);
+            int2x3 b0 = int2x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695);
+            bool2x3 r0 = bool2x3(true, true, false, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x3 a1 = int2x3(241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            int2x3 b1 = int2x3(253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool2x3 r1 = bool2x3(false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x3 a2 = int2x3(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            int2x3 b2 = int2x3(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool2x3 r2 = bool2x3(false, false, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x3 a3 = int2x3(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int2x3 b3 = int2x3(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool2x3 r3 = bool2x3(false, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_wide_scalar()
+        {
+            int2x3 a0 = int2x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111);
+            int b0 = (438688675);
+            bool2x3 r0 = bool2x3(true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x3 a1 = int2x3(1437755186, 2125058448, 304028799, 893125636, 48044515, 711945018);
+            int b1 = (1219010035);
+            bool2x3 r1 = bool2x3(true, true, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x3 a2 = int2x3(1035679270, 572743717, 1016617211, 2063134811, 1577403353, 64009107);
+            int b2 = (577943770);
+            bool2x3 r2 = bool2x3(true, false, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x3 a3 = int2x3(1462961460, 3715845, 689362811, 263973424, 1045140419, 1058332184);
+            int b3 = (1143565920);
+            bool2x3 r3 = bool2x3(true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int2x3 b0 = int2x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500);
+            bool2x3 r0 = bool2x3(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1443698859);
+            int2x3 b1 = int2x3(779217735, 691047512, 741776730, 732565983, 668302204, 1556466996);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (858599525);
+            int2x3 b2 = int2x3(1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345);
+            bool2x3 r2 = bool2x3(false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (299897686);
+            int2x3 b3 = int2x3(632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_equal_wide_wide()
+        {
+            int2x3 a0 = int2x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140);
+            int2x3 b0 = int2x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830);
+            bool2x3 r0 = bool2x3(false, true, false, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x3 a1 = int2x3(1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            int2x3 b1 = int2x3(1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool2x3 r1 = bool2x3(false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x3 a2 = int2x3(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            int2x3 b2 = int2x3(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool2x3 r2 = bool2x3(false, false, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x3 a3 = int2x3(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int2x3 b3 = int2x3(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool2x3 r3 = bool2x3(true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_equal_wide_scalar()
+        {
+            int2x3 a0 = int2x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951);
+            int b0 = (1688048545);
+            bool2x3 r0 = bool2x3(false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x3 a1 = int2x3(212084836, 1459242706, 1745758438, 532949158, 262559763, 690091301);
+            int b1 = (58924407);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x3 a2 = int2x3(1806172431, 1857173043, 1617221948, 2017733017, 804204255, 981729559);
+            int b2 = (2091514001);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x3 a3 = int2x3(2032949254, 2079225209, 26179915, 238796519, 1917813750, 1258115260);
+            int b3 = (910922522);
+            bool2x3 r3 = bool2x3(false, false, true, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int2x3 b0 = int2x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1678863148);
+            int2x3 b1 = int2x3(1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493);
+            bool2x3 r1 = bool2x3(true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (48893340);
+            int2x3 b2 = int2x3(66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (117849810);
+            int2x3 b3 = int2x3(1348693584, 105489302, 259034238, 530713566, 601413850, 830430286);
+            bool2x3 r3 = bool2x3(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_equal_wide_wide()
+        {
+            int2x3 a0 = int2x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687);
+            int2x3 b0 = int2x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472);
+            bool2x3 r0 = bool2x3(false, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x3 a1 = int2x3(816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            int2x3 b1 = int2x3(290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool2x3 r1 = bool2x3(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x3 a2 = int2x3(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            int2x3 b2 = int2x3(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool2x3 r2 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x3 a3 = int2x3(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int2x3 b3 = int2x3(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool2x3 r3 = bool2x3(false, true, false, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_equal_wide_scalar()
+        {
+            int2x3 a0 = int2x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132);
+            int b0 = (1470533736);
+            bool2x3 r0 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x3 a1 = int2x3(1186600258, 609211196, 1604309397, 829548642, 244604867, 1419295004);
+            int b1 = (815093894);
+            bool2x3 r1 = bool2x3(true, false, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x3 a2 = int2x3(471843809, 1460027917, 1646290021, 196833647, 1596738181, 1905036391);
+            int b2 = (1819986195);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x3 a3 = int2x3(1771391775, 370941146, 440219668, 1607345862, 1449142607, 1223010129);
+            int b3 = (1584946560);
+            bool2x3 r3 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int2x3 b0 = int2x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (118252990);
+            int2x3 b1 = int2x3(1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (917376832);
+            int2x3 b2 = int2x3(303549425, 2111728811, 945321577, 173706579, 625318949, 519443238);
+            bool2x3 r2 = bool2x3(true, false, false, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (1583588379);
+            int2x3 b3 = int2x3(1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308);
+            bool2x3 r3 = bool2x3(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_add_wide_wide()
+        {
+            int2x3 a0 = int2x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558);
+            int2x3 b0 = int2x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874);
+            int2x3 r0 = int2x3(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x3 a1 = int2x3(86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            int2x3 b1 = int2x3(1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            int2x3 r1 = int2x3(1721667438, -1850333135, -2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x3 a2 = int2x3(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            int2x3 b2 = int2x3(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            int2x3 r2 = int2x3(-147610603, 749502583, 623052937, -1181627673, -2116725070, -1148541136);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x3 a3 = int2x3(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int2x3 b3 = int2x3(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int2x3 r3 = int2x3(1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_add_wide_scalar()
+        {
+            int2x3 a0 = int2x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871);
+            int b0 = (2124409227);
+            int2x3 r0 = int2x3(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x3 a1 = int2x3(1067888129, 2003021861, 1635971971, 1160398286, 85446202, 1068152966);
+            int b1 = (70433301);
+            int2x3 r1 = int2x3(1138321430, 2073455162, 1706405272, 1230831587, 155879503, 1138586267);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x3 a2 = int2x3(1239387100, 1727477485, 1095438654, 756559204, 1818718931, 658923552);
+            int b2 = (1497676888);
+            int2x3 r2 = int2x3(-1557903308, -1069812923, -1701851754, -2040731204, -978571477, -2138366856);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x3 a3 = int2x3(1610518921, 692843300, 1068593469, 1704776233, 577782260, 736972565);
+            int b3 = (1585755398);
+            int2x3 r3 = int2x3(-1098692977, -2016368598, -1640618429, -1004435665, -2131429638, -1972239333);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int2x3 b0 = int2x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201);
+            int2x3 r0 = int2x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (1451896269);
+            int2x3 b1 = int2x3(1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445);
+            int2x3 r1 = int2x3(-1061373955, -1847039202, -1285296078, -2063296087, -1731529725, -2060024582);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1130163944);
+            int2x3 b2 = int2x3(288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965);
+            int2x3 r2 = int2x3(1418443528, -1767119491, -1528219863, 1803427283, -1695502478, 1145019909);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1116636999);
+            int2x3 b3 = int2x3(1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835);
+            int2x3 r3 = int2x3(-1689466997, -1577339411, 1307288300, -1870870529, 2036722838, -1096100462);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_sub_wide_wide()
+        {
+            int2x3 a0 = int2x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435);
+            int2x3 b0 = int2x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701);
+            int2x3 r0 = int2x3(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x3 a1 = int2x3(1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            int2x3 b1 = int2x3(810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            int2x3 r1 = int2x3(570660497, -136914747, 1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x3 a2 = int2x3(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            int2x3 b2 = int2x3(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            int2x3 r2 = int2x3(-50205903, -930193352, 120810088, 929308315, -624402009, -165899077);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x3 a3 = int2x3(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int2x3 b3 = int2x3(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int2x3 r3 = int2x3(-728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_sub_wide_scalar()
+        {
+            int2x3 a0 = int2x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714);
+            int b0 = (462232403);
+            int2x3 r0 = int2x3(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x3 a1 = int2x3(1502312334, 281174200, 87530840, 1913724431, 2041593336, 557239990);
+            int b1 = (1451794815);
+            int2x3 r1 = int2x3(50517519, -1170620615, -1364263975, 461929616, 589798521, -894554825);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x3 a2 = int2x3(1119051448, 819090189, 816382635, 815920639, 1829033117, 1792801932);
+            int b2 = (1590376732);
+            int2x3 r2 = int2x3(-471325284, -771286543, -773994097, -774456093, 238656385, 202425200);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x3 a3 = int2x3(1113440549, 1277257189, 2092779398, 642236742, 1605250794, 819644478);
+            int b3 = (1418937976);
+            int2x3 r3 = int2x3(-305497427, -141680787, 673841422, -776701234, 186312818, -599293498);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int2x3 b0 = int2x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538);
+            int2x3 r0 = int2x3(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (939035482);
+            int2x3 b1 = int2x3(935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109);
+            int2x3 r1 = int2x3(3793205, -850264939, 674322589, -292820585, -879077266, -489400627);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (1258745460);
+            int2x3 b2 = int2x3(1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918);
+            int2x3 r2 = int2x3(181365064, -71977259, 740633631, 291616931, 914079206, 176477542);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (907866696);
+            int2x3 b3 = int2x3(1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777);
+            int2x3 r3 = int2x3(-909018427, 447526128, -54287802, 350753235, -793350013, -1072232081);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mul_wide_wide()
+        {
+            int2x3 a0 = int2x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440);
+            int2x3 b0 = int2x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665);
+            int2x3 r0 = int2x3(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x3 a1 = int2x3(2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            int2x3 b1 = int2x3(1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            int2x3 r1 = int2x3(2128344329, -594088068, -1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x3 a2 = int2x3(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            int2x3 b2 = int2x3(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            int2x3 r2 = int2x3(990589280, -938173952, -1341723466, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x3 a3 = int2x3(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int2x3 b3 = int2x3(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int2x3 r3 = int2x3(1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mul_wide_scalar()
+        {
+            int2x3 a0 = int2x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909);
+            int b0 = (1476837906);
+            int2x3 r0 = int2x3(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x3 a1 = int2x3(72749215, 975743632, 573770299, 1958912969, 971327747, 1818877398);
+            int b1 = (154616909);
+            int2x3 r1 = int2x3(1400257491, 7966032, 499040191, 322676597, 469811687, -373386914);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x3 a2 = int2x3(1324050764, 1279757657, 391009467, 1186856590, 890343818, 800117742);
+            int b2 = (660611671);
+            int2x3 r2 = int2x3(645718228, -42542273, -1778409075, 1570790978, -133379610, 1820172770);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x3 a3 = int2x3(606927173, 1688964615, 1439447294, 387721300, 1192501703, 1613845584);
+            int b3 = (1338014500);
+            int2x3 r3 = int2x3(-254331724, 1134384636, 1352273336, -229242928, 1766808828, 645024576);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int2x3 b0 = int2x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654);
+            int2x3 r0 = int2x3(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1408757883);
+            int2x3 b1 = int2x3(335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231);
+            int2x3 r1 = int2x3(1223039806, 1995624689, -974691120, 375843636, 858017565, 2027534157);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1336308795);
+            int2x3 b2 = int2x3(517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700);
+            int2x3 r2 = int2x3(580046269, -997870016, -325015397, 831291671, -1034573003, -1254339924);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (677771573);
+            int2x3 b3 = int2x3(2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236);
+            int2x3 r3 = int2x3(-125843839, 1435043573, 698030233, 9173379, -824638806, 113055164);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_div_wide_wide()
+        {
+            int2x3 a0 = int2x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154);
+            int2x3 b0 = int2x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613);
+            int2x3 r0 = int2x3(1, 0, 0, 8, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x3 a1 = int2x3(1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            int2x3 b1 = int2x3(878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            int2x3 r1 = int2x3(2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x3 a2 = int2x3(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            int2x3 b2 = int2x3(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            int2x3 r2 = int2x3(0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x3 a3 = int2x3(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int2x3 b3 = int2x3(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int2x3 r3 = int2x3(0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_div_wide_scalar()
+        {
+            int2x3 a0 = int2x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408);
+            int b0 = (947861580);
+            int2x3 r0 = int2x3(0, 1, 0, 1, 2, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x3 a1 = int2x3(1349573078, 341995568, 495895326, 1515313790, 1676971657, 2131487088);
+            int b1 = (524526253);
+            int2x3 r1 = int2x3(2, 0, 0, 2, 3, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x3 a2 = int2x3(2105094094, 542666029, 1646044372, 1447236569, 107215658, 19616726);
+            int b2 = (1017891310);
+            int2x3 r2 = int2x3(2, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x3 a3 = int2x3(896899915, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864);
+            int b3 = (707389627);
+            int2x3 r3 = int2x3(1, 1, 2, 2, 2, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int2x3 b0 = int2x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283);
+            int2x3 r0 = int2x3(6, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (1773486938);
+            int2x3 b1 = int2x3(1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637);
+            int2x3 r1 = int2x3(1, 21, 1, 2, 38, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (396671391);
+            int2x3 b2 = int2x3(784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453);
+            int2x3 r2 = int2x3(0, 0, 0, 0, 1, 8);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (1796936382);
+            int2x3 b3 = int2x3(1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083);
+            int2x3 r3 = int2x3(1, 1, 0, 2, 1, 5);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mod_wide_wide()
+        {
+            int2x3 a0 = int2x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460);
+            int2x3 b0 = int2x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852);
+            int2x3 r0 = int2x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x3 a1 = int2x3(861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            int2x3 b1 = int2x3(2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            int2x3 r1 = int2x3(861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x3 a2 = int2x3(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            int2x3 b2 = int2x3(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            int2x3 r2 = int2x3(137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x3 a3 = int2x3(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int2x3 b3 = int2x3(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int2x3 r3 = int2x3(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mod_wide_scalar()
+        {
+            int2x3 a0 = int2x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208);
+            int b0 = (883951171);
+            int2x3 r0 = int2x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x3 a1 = int2x3(128329633, 896587769, 405208598, 1982762194, 959236935, 712321026);
+            int b1 = (1464010899);
+            int2x3 r1 = int2x3(128329633, 896587769, 405208598, 518751295, 959236935, 712321026);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x3 a2 = int2x3(172564850, 1085897743, 1607489717, 165478511, 647846716, 915707999);
+            int b2 = (1540068445);
+            int2x3 r2 = int2x3(172564850, 1085897743, 67421272, 165478511, 647846716, 915707999);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x3 a3 = int2x3(1602830401, 1084934806, 488509689, 2087820912, 377501313, 1778384846);
+            int b3 = (928191283);
+            int2x3 r3 = int2x3(674639118, 156743523, 488509689, 231438346, 377501313, 850193563);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int2x3 b0 = int2x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038);
+            int2x3 r0 = int2x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1906405167);
+            int2x3 b1 = int2x3(247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643);
+            int2x3 r1 = int2x3(172552312, 145641729, 411110001, 159757961, 314361468, 608302524);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (2057984657);
+            int2x3 b2 = int2x3(1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997);
+            int2x3 r2 = int2x3(56500475, 596612526, 198242315, 463615283, 414206973, 974791660);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (840114986);
+            int2x3 b3 = int2x3(1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061);
+            int2x3 r3 = int2x3(840114986, 224955022, 840114986, 217454, 840114986, 17224681);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_plus()
+        {
+            int2x3 a0 = int2x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            int2x3 r0 = int2x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            TestUtils.AreEqual(+a0, r0);
+
+            int2x3 a1 = int2x3(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            int2x3 r1 = int2x3(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            TestUtils.AreEqual(+a1, r1);
+
+            int2x3 a2 = int2x3(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            int2x3 r2 = int2x3(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            TestUtils.AreEqual(+a2, r2);
+
+            int2x3 a3 = int2x3(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            int2x3 r3 = int2x3(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_neg()
+        {
+            int2x3 a0 = int2x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593);
+            int2x3 r0 = int2x3(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593);
+            TestUtils.AreEqual(-a0, r0);
+
+            int2x3 a1 = int2x3(33894270, 1115028238, 1636274969, 694995093, 1542206286, 213087293);
+            int2x3 r1 = int2x3(-33894270, -1115028238, -1636274969, -694995093, -1542206286, -213087293);
+            TestUtils.AreEqual(-a1, r1);
+
+            int2x3 a2 = int2x3(243937487, 841085242, 574159094, 1687250035, 2057919693, 1175014732);
+            int2x3 r2 = int2x3(-243937487, -841085242, -574159094, -1687250035, -2057919693, -1175014732);
+            TestUtils.AreEqual(-a2, r2);
+
+            int2x3 a3 = int2x3(1259809073, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454);
+            int2x3 r3 = int2x3(-1259809073, -1190569920, -2047955772, -2120729864, -1440774928, -1485596454);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_prefix_inc()
+        {
+            int2x3 a0 = int2x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725);
+            int2x3 r0 = int2x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726);
+            TestUtils.AreEqual(++a0, r0);
+
+            int2x3 a1 = int2x3(395072276, 913293639, 432884105, 1208161871, 1385544935, 1835605516);
+            int2x3 r1 = int2x3(395072277, 913293640, 432884106, 1208161872, 1385544936, 1835605517);
+            TestUtils.AreEqual(++a1, r1);
+
+            int2x3 a2 = int2x3(831396561, 696475402, 1786514683, 993189311, 752093909, 1622410417);
+            int2x3 r2 = int2x3(831396562, 696475403, 1786514684, 993189312, 752093910, 1622410418);
+            TestUtils.AreEqual(++a2, r2);
+
+            int2x3 a3 = int2x3(1398865015, 1705625817, 609525897, 172599489, 504806865, 519296647);
+            int2x3 r3 = int2x3(1398865016, 1705625818, 609525898, 172599490, 504806866, 519296648);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_postfix_inc()
+        {
+            int2x3 a0 = int2x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            int2x3 r0 = int2x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            TestUtils.AreEqual(a0++, r0);
+
+            int2x3 a1 = int2x3(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            int2x3 r1 = int2x3(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            TestUtils.AreEqual(a1++, r1);
+
+            int2x3 a2 = int2x3(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            int2x3 r2 = int2x3(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            TestUtils.AreEqual(a2++, r2);
+
+            int2x3 a3 = int2x3(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            int2x3 r3 = int2x3(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_prefix_dec()
+        {
+            int2x3 a0 = int2x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037);
+            int2x3 r0 = int2x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036);
+            TestUtils.AreEqual(--a0, r0);
+
+            int2x3 a1 = int2x3(1782514098, 1434377580, 596759698, 1699290403, 1758478358, 1914114460);
+            int2x3 r1 = int2x3(1782514097, 1434377579, 596759697, 1699290402, 1758478357, 1914114459);
+            TestUtils.AreEqual(--a1, r1);
+
+            int2x3 a2 = int2x3(71237375, 1022184392, 1310293956, 356565557, 18299409, 906734601);
+            int2x3 r2 = int2x3(71237374, 1022184391, 1310293955, 356565556, 18299408, 906734600);
+            TestUtils.AreEqual(--a2, r2);
+
+            int2x3 a3 = int2x3(799006218, 1040798388, 1469596990, 1719228297, 220897829, 1454322707);
+            int2x3 r3 = int2x3(799006217, 1040798387, 1469596989, 1719228296, 220897828, 1454322706);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_postfix_dec()
+        {
+            int2x3 a0 = int2x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            int2x3 r0 = int2x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            TestUtils.AreEqual(a0--, r0);
+
+            int2x3 a1 = int2x3(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            int2x3 r1 = int2x3(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            TestUtils.AreEqual(a1--, r1);
+
+            int2x3 a2 = int2x3(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            int2x3 r2 = int2x3(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            TestUtils.AreEqual(a2--, r2);
+
+            int2x3 a3 = int2x3(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            int2x3 r3 = int2x3(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_and_wide_wide()
+        {
+            int2x3 a0 = int2x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558);
+            int2x3 b0 = int2x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877);
+            int2x3 r0 = int2x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x3 a1 = int2x3(1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            int2x3 b1 = int2x3(1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            int2x3 r1 = int2x3(1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x3 a2 = int2x3(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            int2x3 b2 = int2x3(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            int2x3 r2 = int2x3(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x3 a3 = int2x3(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int2x3 b3 = int2x3(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int2x3 r3 = int2x3(168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_and_wide_scalar()
+        {
+            int2x3 a0 = int2x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004);
+            int b0 = (93423598);
+            int2x3 r0 = int2x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x3 a1 = int2x3(1941875181, 1365509729, 428270198, 607982857, 650270920, 1249238550);
+            int b1 = (1236735839);
+            int2x3 r1 = int2x3(1102446925, 1092879937, 159777366, 3478793, 8523848, 1211438614);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x3 a2 = int2x3(814629680, 143502472, 861733033, 1408932942, 957693145, 1567715668);
+            int b2 = (1862276471);
+            int2x3 r2 = int2x3(536871216, 134218752, 587202593, 1124078662, 687871057, 1291850068);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x3 a3 = int2x3(1102952410, 1599352836, 208656708, 1272226025, 462670926, 1817145060);
+            int b3 = (322053683);
+            int2x3 r3 = int2x3(19932690, 319823872, 2228224, 51388449, 319947778, 140832);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int2x3 b0 = int2x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958);
+            int2x3 r0 = int2x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1159378889);
+            int2x3 b1 = int2x3(2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957);
+            int2x3 r1 = int2x3(1091605257, 1074836865, 9161, 1074299840, 83924360, 1092133121);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1248975349);
+            int2x3 b2 = int2x3(236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522);
+            int2x3 r2 = int2x3(168903041, 167844145, 1075925380, 1241581744, 140613985, 1074872496);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (2042776519);
+            int2x3 b3 = int2x3(56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404);
+            int2x3 r3 = int2x3(21118982, 1770146496, 1769996867, 1371555910, 1229064577, 1212170948);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_or_wide_wide()
+        {
+            int2x3 a0 = int2x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514);
+            int2x3 b0 = int2x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212);
+            int2x3 r0 = int2x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x3 a1 = int2x3(948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            int2x3 b1 = int2x3(2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            int2x3 r1 = int2x3(2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x3 a2 = int2x3(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            int2x3 b2 = int2x3(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            int2x3 r2 = int2x3(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x3 a3 = int2x3(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int2x3 b3 = int2x3(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int2x3 r3 = int2x3(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_or_wide_scalar()
+        {
+            int2x3 a0 = int2x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449);
+            int b0 = (1666102508);
+            int2x3 r0 = int2x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x3 a1 = int2x3(1048929715, 860336789, 1637162093, 1227888278, 774029856, 879300408);
+            int b1 = (1814263250);
+            int2x3 r1 = int2x3(2124903923, 2137520087, 1840741887, 1832089558, 1847850994, 2087419898);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x3 a2 = int2x3(1179087439, 1977614655, 46921989, 1980838747, 284225881, 64304104);
+            int b2 = (797240690);
+            int2x3 r2 = int2x3(1875378047, 2145709439, 802159991, 2140536699, 1073020283, 802553850);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x3 a3 = int2x3(313591807, 1890090886, 521303722, 2021379070, 2055963359, 1511253082);
+            int b3 = (1393862490);
+            int2x3 r3 = int2x3(1404413951, 1941766110, 1595340794, 2071982078, 2074060767, 1528293210);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int2x3 b0 = int2x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481);
+            int2x3 r0 = int2x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (1283571271);
+            int2x3 b1 = int2x3(2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741);
+            int2x3 r1 = int2x3(2109210439, 2128723919, 1558052575, 1608908663, 1838415447, 2141322991);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (627815046);
+            int2x3 b2 = int2x3(418822515, 83214352, 424663473, 447949225, 527022375, 1947148461);
+            int2x3 r2 = int2x3(1040169975, 637530774, 1030749111, 1073462191, 1064024999, 1970254511);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (305251437);
+            int2x3 b3 = int2x3(1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808);
+            int2x3 r3 = int2x3(1526199917, 2054417661, 1593566973, 1589235437, 1391839215, 335281389);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_xor_wide_wide()
+        {
+            int2x3 a0 = int2x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585);
+            int2x3 b0 = int2x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205);
+            int2x3 r0 = int2x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x3 a1 = int2x3(220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            int2x3 b1 = int2x3(535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            int2x3 r1 = int2x3(314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x3 a2 = int2x3(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            int2x3 b2 = int2x3(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            int2x3 r2 = int2x3(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x3 a3 = int2x3(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int2x3 b3 = int2x3(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int2x3 r3 = int2x3(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_xor_wide_scalar()
+        {
+            int2x3 a0 = int2x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690);
+            int b0 = (493665894);
+            int2x3 r0 = int2x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x3 a1 = int2x3(535061373, 1305234431, 353786540, 1308626970, 1267729267, 125659640);
+            int b1 = (289301586);
+            int2x3 r1 = int2x3(249169711, 1559375789, 69746430, 1597928520, 1521379105, 373493162);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x3 a2 = int2x3(1315625690, 116862046, 375757978, 491079274, 191750702, 187129429);
+            int b2 = (1730088797);
+            int2x3 r2 = int2x3(695588231, 1642603267, 1903858631, 2052737335, 1819471219, 1815630088);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x3 a3 = int2x3(967051293, 653124416, 788984, 1479174924, 1680011736, 447453839);
+            int b3 = (549951551);
+            int2x3 r3 = int2x3(425955362, 103447423, 550212039, 2028860211, 1155885543, 980157104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int2x3 b0 = int2x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275);
+            int2x3 r0 = int2x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1416249064);
+            int2x3 b1 = int2x3(1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003);
+            int2x3 r1 = int2x3(442541185, 1037166305, 227827390, 327742460, 280796832, 544217587);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1774252400);
+            int2x3 b2 = int2x3(1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053);
+            int2x3 r2 = int2x3(440379266, 698081028, 2022864761, 1000608691, 1580745115, 667852101);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (221134131);
+            int2x3 b3 = int2x3(885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520);
+            int2x3 r3 = int2x3(971170309, 693458543, 113181510, 1584258954, 790500762, 1630705027);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_left_shift()
+        {
+            int2x3 a0 = int2x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717);
+            int b0 = (1321149625);
+            int2x3 r0 = int2x3(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int2x3 a1 = int2x3(870301196, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302);
+            int b1 = (2058433484);
+            int2x3 r1 = int2x3(-69156864, 306012160, -1482059776, 20340736, -1775935488, -1561206784);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int2x3 a2 = int2x3(1079614371, 1664454606, 2045594989, 2077023268, 592678686, 297755411);
+            int b2 = (35667343);
+            int2x3 r2 = int2x3(-841908224, -941162496, -1497989120, 1846673408, -946929664, -1316388864);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int2x3 a3 = int2x3(1722762487, 37265945, 997793693, 1521705181, 263886278, 221147365);
+            int b3 = (1161625759);
+            int2x3 r3 = int2x3(-2147483648, -2147483648, -2147483648, -2147483648, 0, -2147483648);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_right_shift()
+        {
+            int2x3 a0 = int2x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656);
+            int b0 = (1266801540);
+            int2x3 r0 = int2x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int2x3 a1 = int2x3(770466193, 572763124, 506619530, 426807581, 2031319045, 701927980);
+            int b1 = (1265099998);
+            int2x3 r1 = int2x3(0, 0, 0, 0, 1, 0);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int2x3 a2 = int2x3(917785020, 185593382, 1102123711, 334005460, 1624751550, 280138733);
+            int b2 = (569504877);
+            int2x3 r2 = int2x3(112034, 22655, 134536, 40772, 198333, 34196);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int2x3 a3 = int2x3(1598620011, 736389149, 1279158873, 408822762, 763607760, 348013684);
+            int b3 = (1840564178);
+            int2x3 r3 = int2x3(6098, 2809, 4879, 1559, 2912, 1327);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x3_operator_bitwise_not()
+        {
+            int2x3 a0 = int2x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339);
+            int2x3 r0 = int2x3(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340);
+            TestUtils.AreEqual(~a0, r0);
+
+            int2x3 a1 = int2x3(1935567517, 472965491, 771711426, 627580960, 2061524024, 753208488);
+            int2x3 r1 = int2x3(-1935567518, -472965492, -771711427, -627580961, -2061524025, -753208489);
+            TestUtils.AreEqual(~a1, r1);
+
+            int2x3 a2 = int2x3(2097179283, 664744603, 1289372466, 1635981125, 1951018596, 1545651937);
+            int2x3 r2 = int2x3(-2097179284, -664744604, -1289372467, -1635981126, -1951018597, -1545651938);
+            TestUtils.AreEqual(~a2, r2);
+
+            int2x3 a3 = int2x3(717936457, 1342785385, 869629475, 2045854321, 1282546942, 1562433528);
+            int2x3 r3 = int2x3(-717936458, -1342785386, -869629476, -2045854322, -1282546943, -1562433529);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..d64f81d4bf675d08f69027c9fbbeb72a7cea88f9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6a957081e92e7e5429649cd56b5453b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..27cb587fcd96f6e2760f0f0676b5d57fb62f2e78
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs
@@ -0,0 +1,1229 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt2x4
+    {
+        [TestCompiler]
+        public static void int2x4_zero()
+        {
+            TestUtils.AreEqual(int2x4.zero.c0.x, 0);
+            TestUtils.AreEqual(int2x4.zero.c0.y, 0);
+            TestUtils.AreEqual(int2x4.zero.c1.x, 0);
+            TestUtils.AreEqual(int2x4.zero.c1.y, 0);
+            TestUtils.AreEqual(int2x4.zero.c2.x, 0);
+            TestUtils.AreEqual(int2x4.zero.c2.y, 0);
+            TestUtils.AreEqual(int2x4.zero.c3.x, 0);
+            TestUtils.AreEqual(int2x4.zero.c3.y, 0);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_equal_wide_wide()
+        {
+            int2x4 a0 = int2x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370);
+            int2x4 b0 = int2x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x4 a1 = int2x4(1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            int2x4 b1 = int2x4(1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x4 a2 = int2x4(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int2x4 b2 = int2x4(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x4 a3 = int2x4(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            int2x4 b3 = int2x4(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_equal_wide_scalar()
+        {
+            int2x4 a0 = int2x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277);
+            int b0 = (746972502);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int2x4 a1 = int2x4(1682018538, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077);
+            int b1 = (795585660);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int2x4 a2 = int2x4(442746747, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678);
+            int b2 = (1772925698);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int2x4 a3 = int2x4(1305479811, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832);
+            int b3 = (255635293);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int2x4 b0 = int2x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1061805787);
+            int2x4 b1 = int2x4(1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (2003197687);
+            int2x4 b2 = int2x4(1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (367814403);
+            int2x4 b3 = int2x4(1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_not_equal_wide_wide()
+        {
+            int2x4 a0 = int2x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646);
+            int2x4 b0 = int2x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x4 a1 = int2x4(1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            int2x4 b1 = int2x4(1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x4 a2 = int2x4(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int2x4 b2 = int2x4(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x4 a3 = int2x4(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            int2x4 b3 = int2x4(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_not_equal_wide_scalar()
+        {
+            int2x4 a0 = int2x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450);
+            int b0 = (248693828);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int2x4 a1 = int2x4(2105962247, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883);
+            int b1 = (727205263);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int2x4 a2 = int2x4(1622176923, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685);
+            int b2 = (768370497);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int2x4 a3 = int2x4(904014575, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907);
+            int b3 = (384643370);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int2x4 b0 = int2x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (124108032);
+            int2x4 b1 = int2x4(1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (266984506);
+            int2x4 b2 = int2x4(2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (572038024);
+            int2x4 b3 = int2x4(1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_wide_wide()
+        {
+            int2x4 a0 = int2x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973);
+            int2x4 b0 = int2x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202);
+            bool2x4 r0 = bool2x4(false, true, false, false, false, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x4 a1 = int2x4(928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            int2x4 b1 = int2x4(2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool2x4 r1 = bool2x4(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x4 a2 = int2x4(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int2x4 b2 = int2x4(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool2x4 r2 = bool2x4(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x4 a3 = int2x4(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            int2x4 b3 = int2x4(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool2x4 r3 = bool2x4(false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_wide_scalar()
+        {
+            int2x4 a0 = int2x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341);
+            int b0 = (1491216667);
+            bool2x4 r0 = bool2x4(true, true, true, false, true, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int2x4 a1 = int2x4(840091491, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709);
+            int b1 = (469591900);
+            bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int2x4 a2 = int2x4(1286331950, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110);
+            int b2 = (380753337);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int2x4 a3 = int2x4(867559111, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996);
+            int b3 = (1703747625);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int2x4 b0 = int2x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255);
+            bool2x4 r0 = bool2x4(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (111349251);
+            int2x4 b1 = int2x4(1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1027318999);
+            int2x4 b2 = int2x4(146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400);
+            bool2x4 r2 = bool2x4(false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (1329939911);
+            int2x4 b3 = int2x4(1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_wide_wide()
+        {
+            int2x4 a0 = int2x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550);
+            int2x4 b0 = int2x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742);
+            bool2x4 r0 = bool2x4(true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x4 a1 = int2x4(2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            int2x4 b1 = int2x4(910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool2x4 r1 = bool2x4(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x4 a2 = int2x4(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int2x4 b2 = int2x4(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x4 a3 = int2x4(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            int2x4 b3 = int2x4(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool2x4 r3 = bool2x4(true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_wide_scalar()
+        {
+            int2x4 a0 = int2x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035);
+            int b0 = (438688675);
+            bool2x4 r0 = bool2x4(true, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int2x4 a1 = int2x4(2125058448, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211);
+            int b1 = (304028799);
+            bool2x4 r1 = bool2x4(true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int2x4 a2 = int2x4(2063134811, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419);
+            int b2 = (1577403353);
+            bool2x4 r2 = bool2x4(true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int2x4 a3 = int2x4(1058332184, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708);
+            int b3 = (524569092);
+            bool2x4 r3 = bool2x4(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int2x4 b0 = int2x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735);
+            bool2x4 r0 = bool2x4(true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (691047512);
+            int2x4 b1 = int2x4(741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621);
+            bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1023307544);
+            int2x4 b2 = int2x4(1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900);
+            bool2x4 r2 = bool2x4(false, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (315569296);
+            int2x4 b3 = int2x4(292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844);
+            bool2x4 r3 = bool2x4(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_equal_wide_wide()
+        {
+            int2x4 a0 = int2x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394);
+            int2x4 b0 = int2x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595);
+            bool2x4 r0 = bool2x4(false, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x4 a1 = int2x4(117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            int2x4 b1 = int2x4(1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool2x4 r1 = bool2x4(true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x4 a2 = int2x4(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int2x4 b2 = int2x4(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool2x4 r2 = bool2x4(true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x4 a3 = int2x4(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            int2x4 b3 = int2x4(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool2x4 r3 = bool2x4(false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_equal_wide_scalar()
+        {
+            int2x4 a0 = int2x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407);
+            int b0 = (1688048545);
+            bool2x4 r0 = bool2x4(false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int2x4 a1 = int2x4(1459242706, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948);
+            int b1 = (1745758438);
+            bool2x4 r1 = bool2x4(true, true, true, true, false, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int2x4 a2 = int2x4(2017733017, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750);
+            int b2 = (804204255);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int2x4 a3 = int2x4(1258115260, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122);
+            int b3 = (20607406);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int2x4 b0 = int2x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (762067160);
+            int2x4 b1 = int2x4(11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309);
+            bool2x4 r1 = bool2x4(false, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (861890786);
+            int2x4 b2 = int2x4(478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850);
+            bool2x4 r2 = bool2x4(false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (830430286);
+            int2x4 b3 = int2x4(145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788);
+            bool2x4 r3 = bool2x4(false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_equal_wide_wide()
+        {
+            int2x4 a0 = int2x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546);
+            int2x4 b0 = int2x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862);
+            bool2x4 r0 = bool2x4(false, false, true, false, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x4 a1 = int2x4(1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            int2x4 b1 = int2x4(396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool2x4 r1 = bool2x4(true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x4 a2 = int2x4(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int2x4 b2 = int2x4(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool2x4 r2 = bool2x4(false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x4 a3 = int2x4(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            int2x4 b3 = int2x4(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool2x4 r3 = bool2x4(false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_equal_wide_scalar()
+        {
+            int2x4 a0 = int2x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894);
+            int b0 = (1470533736);
+            bool2x4 r0 = bool2x4(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int2x4 a1 = int2x4(609211196, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021);
+            int b1 = (1604309397);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int2x4 a2 = int2x4(196833647, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607);
+            int b2 = (1596738181);
+            bool2x4 r2 = bool2x4(false, true, true, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int2x4 a3 = int2x4(1223010129, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090);
+            int b3 = (379014762);
+            bool2x4 r3 = bool2x4(true, true, false, true, true, false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int2x4 b0 = int2x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (1240253990);
+            int2x4 b1 = int2x4(1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577);
+            bool2x4 r1 = bool2x4(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (173706579);
+            int2x4 b2 = int2x4(625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (233894308);
+            int2x4 b3 = int2x4(479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835);
+            bool2x4 r3 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_add_wide_wide()
+        {
+            int2x4 a0 = int2x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721);
+            int2x4 b0 = int2x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440);
+            int2x4 r0 = int2x4(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x4 a1 = int2x4(698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            int2x4 b1 = int2x4(1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            int2x4 r1 = int2x4(-2009504361, 1101613923, -799189804, 1384643660, -147610603, 749502583, 623052937, -1181627673);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x4 a2 = int2x4(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int2x4 b2 = int2x4(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int2x4 r2 = int2x4(-2116725070, -1148541136, 1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x4 a3 = int2x4(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            int2x4 b3 = int2x4(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            int2x4 r3 = int2x4(-1246101576, -1393575153, 1940611170, 1099044556, -1932199380, 1285092016, -1653104091, -537584005);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_add_wide_scalar()
+        {
+            int2x4 a0 = int2x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301);
+            int b0 = (2124409227);
+            int2x4 r0 = int2x4(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int2x4 a1 = int2x4(2003021861, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654);
+            int b1 = (1635971971);
+            int2x4 r1 = int2x4(-655973464, -1498597039, 1721418173, -1590842359, -1419608225, -1161318437, -931517840, -1563556671);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int2x4 a2 = int2x4(756559204, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260);
+            int b2 = (1818718931);
+            int2x4 r2 = int2x4(-1719689161, -1817324813, -865729444, -890492967, -1783405065, -1407654896, -771472132, -1898466105);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int2x4 a3 = int2x4(736972565, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516);
+            int b3 = (711894571);
+            int2x4 r3 = int2x4(1448867136, 1276152010, -1531336442, -2010235028, -1955066180, -1727372462, 1368643353, 984669087);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int2x4 b0 = int2x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072);
+            int2x4 r0 = int2x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (996031825);
+            int2x4 b1 = int2x4(1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489);
+            int2x4 r1 = int2x4(-1741160522, 1775806765, 2107573127, 1779078270, 2126195769, 1284311409, -1901251610, -1662351982);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (673263339);
+            int2x4 b2 = int2x4(1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839);
+            int2x4 r2 = int2x4(2142564213, 688119304, 1789900338, -2132840657, -2020713071, 863914640, 1980723107, 1593349178);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (2082229835);
+            int2x4 b3 = int2x4(1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222);
+            int2x4 r3 = int2x4(-220331887, -998813003, -1706896009, -1231316299, -724399762, -1098910821, -406590953, -370946239);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_sub_wide_wide()
+        {
+            int2x4 a0 = int2x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138);
+            int2x4 b0 = int2x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885);
+            int2x4 r0 = int2x4(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x4 a1 = int2x4(1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            int2x4 b1 = int2x4(71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            int2x4 r1 = int2x4(1234495882, -838948052, -732179165, -881462314, -50205903, -930193352, 120810088, 929308315);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x4 a2 = int2x4(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int2x4 b2 = int2x4(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int2x4 r2 = int2x4(-624402009, -165899077, -728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x4 a3 = int2x4(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            int2x4 b3 = int2x4(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            int2x4 r3 = int2x4(-183740135, 972642792, -549594154, -1468159992, -730634354, 1218011798, 1846728662, -555907518);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_sub_wide_scalar()
+        {
+            int2x4 a0 = int2x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815);
+            int b0 = (462232403);
+            int2x4 r0 = int2x4(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int2x4 a1 = int2x4(281174200, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635);
+            int b1 = (87530840);
+            int2x4 r1 = int2x4(193643360, 1826193591, 1954062496, 469709150, 1031520608, 1502845892, 731559349, 728851795);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int2x4 a2 = int2x4(815920639, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794);
+            int b2 = (1829033117);
+            int2x4 r2 = int2x4(-1013112478, -36231185, -715592568, -410095141, -551775928, 263746281, -1186796375, -223782323);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int2x4 a3 = int2x4(819644478, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500);
+            int b3 = (1468003019);
+            int2x4 r3 = int2x4(-648358541, -1339699833, -914508762, -450876048, 531741763, 549269739, 349988745, -187017519);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int2x4 b0 = int2x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277);
+            int2x4 r0 = int2x4(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (1789300421);
+            int2x4 b1 = int2x4(264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829);
+            int2x4 r1 = int2x4(1524587528, 557444354, -28812327, 360864312, 530554961, 711920025, 458577702, 1271188592);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (967128529);
+            int2x4 b2 = int2x4(344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709);
+            int2x4 r2 = int2x4(622462275, -115139389, 59261833, -849756594, 506787961, 4974031, 410015068, -734088180);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1980098777);
+            int2x4 b3 = int2x4(730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041);
+            int2x4 r3 = int2x4(1250038225, 535700950, 1126528221, 1841262345, 966908349, 1262009247, 1473341387, 763650736);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mul_wide_wide()
+        {
+            int2x4 a0 = int2x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069);
+            int2x4 b0 = int2x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980);
+            int2x4 r0 = int2x4(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x4 a1 = int2x4(571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            int2x4 b1 = int2x4(1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            int2x4 r1 = int2x4(-1654168033, 2093463192, -1207506618, -1133560830, 990589280, -938173952, -1341723466, 1156600361);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x4 a2 = int2x4(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int2x4 b2 = int2x4(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int2x4 r2 = int2x4(649177976, 678952165, 1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x4 a3 = int2x4(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            int2x4 b3 = int2x4(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            int2x4 r3 = int2x4(1891467339, 335415735, 1128927428, -1656253776, -1433851638, 479369680, -366628060, -250163942);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mul_wide_scalar()
+        {
+            int2x4 a0 = int2x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909);
+            int b0 = (1476837906);
+            int2x4 r0 = int2x4(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int2x4 a1 = int2x4(975743632, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467);
+            int b1 = (573770299);
+            int2x4 r1 = int2x4(414773040, -699623085, 1045098929, -1129153454, 1954692228, 970215437, 1522404739, 631100697);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int2x4 a2 = int2x4(1186856590, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703);
+            int b2 = (890343818);
+            int2x4 r2 = int2x4(218605196, 908725324, -805080014, -1528445592, 1365477062, 1262261996, 2040090952, 691203142);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int2x4 a3 = int2x4(1613845584, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051);
+            int b3 = (76318055);
+            int2x4 r3 = int2x4(-1335460816, 1256424448, -545299589, 628661398, 357366566, 753276674, 2132219401, -825295347);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int2x4 b0 = int2x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146);
+            int2x4 r0 = int2x4(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (2105124483);
+            int2x4 b1 = int2x4(1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225);
+            int2x4 r1 = int2x4(-1028919216, 2084093460, 1286996821, 910923781, 1886305329, -1039959883, 644799552, 1815059427);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (994616533);
+            int2x4 b2 = int2x4(1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330);
+            int2x4 r2 = int2x4(585859259, 2021158292, 1046891801, -1941821535, -738776427, -1715252039, -160572189, 1259643370);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (1186460236);
+            int2x4 b3 = int2x4(657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873);
+            int2x4 r3 = int2x4(-901633076, -879300144, 1278776548, 1761940324, -675287412, 2049744268, -375297800, -1944395988);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_div_wide_wide()
+        {
+            int2x4 a0 = int2x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739);
+            int2x4 b0 = int2x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678);
+            int2x4 r0 = int2x4(1, 0, 0, 8, 0, 0, 2, 7);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x4 a1 = int2x4(499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            int2x4 b1 = int2x4(2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            int2x4 r1 = int2x4(0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x4 a2 = int2x4(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int2x4 b2 = int2x4(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int2x4 r2 = int2x4(1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x4 a3 = int2x4(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            int2x4 b3 = int2x4(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            int2x4 r3 = int2x4(2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_div_wide_scalar()
+        {
+            int2x4 a0 = int2x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253);
+            int b0 = (947861580);
+            int2x4 r0 = int2x4(0, 1, 0, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int2x4 a1 = int2x4(341995568, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372);
+            int b1 = (495895326);
+            int2x4 r1 = int2x4(0, 3, 3, 4, 4, 2, 1, 3);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int2x4 a2 = int2x4(1447236569, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924);
+            int b2 = (107215658);
+            int2x4 r2 = int2x4(13, 0, 8, 6, 11, 13, 16, 17);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int2x4 a3 = int2x4(1244966864, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348);
+            int b3 = (1200843642);
+            int2x4 r3 = int2x4(1, 0, 1, 1, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int2x4 b0 = int2x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032);
+            int2x4 r0 = int2x4(6, 0, 0, 0, 2, 0, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (81831373);
+            int2x4 b1 = int2x4(1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859);
+            int2x4 r1 = int2x4(0, 0, 1, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1653451772);
+            int2x4 b2 = int2x4(270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890);
+            int2x4 r2 = int2x4(6, 33, 0, 1, 1, 0, 2, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (351914083);
+            int2x4 b3 = int2x4(131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708);
+            int2x4 r3 = int2x4(2, 0, 0, 0, 1, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mod_wide_wide()
+        {
+            int2x4 a0 = int2x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532);
+            int2x4 b0 = int2x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806);
+            int2x4 r0 = int2x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x4 a1 = int2x4(778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            int2x4 b1 = int2x4(769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            int2x4 r1 = int2x4(9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x4 a2 = int2x4(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int2x4 b2 = int2x4(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int2x4 r2 = int2x4(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x4 a3 = int2x4(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            int2x4 b3 = int2x4(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            int2x4 r3 = int2x4(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mod_wide_scalar()
+        {
+            int2x4 a0 = int2x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899);
+            int b0 = (883951171);
+            int2x4 r0 = int2x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int2x4 a1 = int2x4(896587769, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717);
+            int b1 = (405208598);
+            int2x4 r1 = int2x4(86170573, 361927802, 148819739, 307112428, 172564850, 324442651, 275480547, 391863923);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int2x4 a2 = int2x4(165478511, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313);
+            int b2 = (647846716);
+            int2x4 r2 = int2x4(165478511, 267861283, 307136969, 280344567, 437088090, 488509689, 144280764, 377501313);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int2x4 a3 = int2x4(1778384846, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942);
+            int b3 = (1216011754);
+            int2x4 r3 = int2x4(562373092, 812183417, 1153802502, 426660116, 708698988, 665297470, 352079071, 834971188);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int2x4 b0 = int2x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265);
+            int2x4 r0 = int2x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (293460573);
+            int2x4 b1 = int2x4(1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342);
+            int2x4 r1 = int2x4(293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (797184687);
+            int2x4 b2 = int2x4(821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318);
+            int2x4 r2 = int2x4(797184687, 797184687, 797184687, 797184687, 182024723, 797184687, 1919391, 797184687);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (164578061);
+            int2x4 b3 = int2x4(730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733);
+            int2x4 r3 = int2x4(164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_plus()
+        {
+            int2x4 a0 = int2x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            int2x4 r0 = int2x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            TestUtils.AreEqual(+a0, r0);
+
+            int2x4 a1 = int2x4(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            int2x4 r1 = int2x4(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            TestUtils.AreEqual(+a1, r1);
+
+            int2x4 a2 = int2x4(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            int2x4 r2 = int2x4(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            TestUtils.AreEqual(+a2, r2);
+
+            int2x4 a3 = int2x4(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            int2x4 r3 = int2x4(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_neg()
+        {
+            int2x4 a0 = int2x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349);
+            int2x4 r0 = int2x4(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349);
+            TestUtils.AreEqual(-a0, r0);
+
+            int2x4 a1 = int2x4(1115028238, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094);
+            int2x4 r1 = int2x4(-1115028238, -694995093, -1542206286, -213087293, -243937487, -341522275, -841085242, -574159094);
+            TestUtils.AreEqual(-a1, r1);
+
+            int2x4 a2 = int2x4(1687250035, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928);
+            int2x4 r2 = int2x4(-1687250035, -1175014732, -1259809073, -1212465326, -1190569920, -2047955772, -2120729864, -1440774928);
+            TestUtils.AreEqual(-a2, r2);
+
+            int2x4 a3 = int2x4(1485596454, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098);
+            int2x4 r3 = int2x4(-1485596454, -1387601718, -1745651998, -319115626, -1119959806, -739132284, -1954173314, -1709857098);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_prefix_inc()
+        {
+            int2x4 a0 = int2x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442);
+            int2x4 r0 = int2x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443);
+            TestUtils.AreEqual(++a0, r0);
+
+            int2x4 a1 = int2x4(913293639, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683);
+            int2x4 r1 = int2x4(913293640, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684);
+            TestUtils.AreEqual(++a1, r1);
+
+            int2x4 a2 = int2x4(993189311, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865);
+            int2x4 r2 = int2x4(993189312, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866);
+            TestUtils.AreEqual(++a2, r2);
+
+            int2x4 a3 = int2x4(519296647, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208);
+            int2x4 r3 = int2x4(519296648, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_postfix_inc()
+        {
+            int2x4 a0 = int2x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            int2x4 r0 = int2x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            TestUtils.AreEqual(a0++, r0);
+
+            int2x4 a1 = int2x4(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            int2x4 r1 = int2x4(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            TestUtils.AreEqual(a1++, r1);
+
+            int2x4 a2 = int2x4(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            int2x4 r2 = int2x4(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            TestUtils.AreEqual(a2++, r2);
+
+            int2x4 a3 = int2x4(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            int2x4 r3 = int2x4(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_prefix_dec()
+        {
+            int2x4 a0 = int2x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826);
+            int2x4 r0 = int2x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825);
+            TestUtils.AreEqual(--a0, r0);
+
+            int2x4 a1 = int2x4(1434377580, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956);
+            int2x4 r1 = int2x4(1434377579, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955);
+            TestUtils.AreEqual(--a1, r1);
+
+            int2x4 a2 = int2x4(356565557, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829);
+            int2x4 r2 = int2x4(356565556, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828);
+            TestUtils.AreEqual(--a2, r2);
+
+            int2x4 a3 = int2x4(1454322707, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343);
+            int2x4 r3 = int2x4(1454322706, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_postfix_dec()
+        {
+            int2x4 a0 = int2x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            int2x4 r0 = int2x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            TestUtils.AreEqual(a0--, r0);
+
+            int2x4 a1 = int2x4(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            int2x4 r1 = int2x4(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            TestUtils.AreEqual(a1--, r1);
+
+            int2x4 a2 = int2x4(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            int2x4 r2 = int2x4(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            TestUtils.AreEqual(a2--, r2);
+
+            int2x4 a3 = int2x4(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            int2x4 r3 = int2x4(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_and_wide_wide()
+        {
+            int2x4 a0 = int2x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406);
+            int2x4 b0 = int2x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812);
+            int2x4 r0 = int2x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x4 a1 = int2x4(2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            int2x4 b1 = int2x4(23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            int2x4 r1 = int2x4(16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x4 a2 = int2x4(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int2x4 b2 = int2x4(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int2x4 r2 = int2x4(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x4 a3 = int2x4(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            int2x4 b3 = int2x4(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            int2x4 r3 = int2x4(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_and_wide_scalar()
+        {
+            int2x4 a0 = int2x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839);
+            int b0 = (93423598);
+            int2x4 r0 = int2x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int2x4 a1 = int2x4(1365509729, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033);
+            int b1 = (428270198);
+            int2x4 r1 = int2x4(285475424, 262144, 8536128, 134529558, 277234224, 150995062, 142909440, 285474848);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int2x4 a2 = int2x4(1408932942, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926);
+            int b2 = (957693145);
+            int2x4 r2 = int2x4(286268488, 420556880, 18167000, 286270481, 420753408, 134551616, 152314057, 420547656);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int2x4 a3 = int2x4(1817145060, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525);
+            int b3 = (1466722981);
+            int2x4 r3 = int2x4(1145858724, 1145069572, 273443365, 101460005, 1093403136, 524420, 335806629, 1142948357);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int2x4 b0 = int2x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279);
+            int2x4 r0 = int2x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1089518981);
+            int2x4 b1 = int2x4(270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038);
+            int2x4 r1 = int2x4(2105729, 1080066432, 40324, 1074831621, 1081121157, 1058177, 14593, 1084233092);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1845693112);
+            int2x4 b2 = int2x4(946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417);
+            int2x4 r2 = int2x4(671287840, 1141047992, 1744964224, 33751056, 1744964256, 1845559864, 1140852752, 1208158384);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1214109404);
+            int2x4 b3 = int2x4(2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506);
+            int2x4 r3 = int2x4(16988, 1208799884, 1074321052, 1209303624, 1115840, 1213727936, 1610312, 1078218760);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_or_wide_wide()
+        {
+            int2x4 a0 = int2x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835);
+            int2x4 b0 = int2x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430);
+            int2x4 r0 = int2x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x4 a1 = int2x4(669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            int2x4 b1 = int2x4(1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            int2x4 r1 = int2x4(1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x4 a2 = int2x4(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int2x4 b2 = int2x4(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int2x4 r2 = int2x4(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x4 a3 = int2x4(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            int2x4 b3 = int2x4(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            int2x4 r3 = int2x4(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_or_wide_scalar()
+        {
+            int2x4 a0 = int2x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250);
+            int b0 = (1666102508);
+            int2x4 r0 = int2x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int2x4 a1 = int2x4(860336789, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989);
+            int b1 = (1637162093);
+            int2x4 r1 = int2x4(1943518973, 1773477631, 1874321005, 1979522941, 1742175855, 1872100735, 1978998143, 1675623789);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int2x4 a2 = int2x4(1980838747, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359);
+            int b2 = (284225881);
+            int2x4 r2 = int2x4(1995567963, 334885881, 317847551, 1408563035, 1895366623, 536016891, 2029779967, 2063332319);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int2x4 a3 = int2x4(1511253082, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895);
+            int b3 = (1775629833);
+            int2x4 r3 = int2x4(2077750875, 1843265467, 1775761279, 2111176313, 2046817999, 2113404623, 1778251405, 2077753039);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int2x4 b0 = int2x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012);
+            int2x4 r0 = int2x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (979469710);
+            int2x4 b1 = int2x4(1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473);
+            int2x4 r1 = int2x4(2055064991, 2078664126, 1005832159, 1063386607, 1064023950, 989314559, 1056294302, 997187007);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (447949225);
+            int2x4 b2 = int2x4(527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150);
+            int2x4 r2 = int2x4(536590767, 2126457261, 447999469, 1526184941, 2062773753, 1593519101, 1589357545, 1526197231);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (298563808);
+            int2x4 b3 = int2x4(2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556);
+            int2x4 r3 = int2x4(2078276845, 872414207, 938213110, 1945092072, 1375468774, 838844392, 1004273386, 836763636);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_xor_wide_wide()
+        {
+            int2x4 a0 = int2x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553);
+            int2x4 b0 = int2x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262);
+            int2x4 r0 = int2x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x4 a1 = int2x4(47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            int2x4 b1 = int2x4(1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            int2x4 r1 = int2x4(1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x4 a2 = int2x4(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int2x4 b2 = int2x4(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int2x4 r2 = int2x4(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x4 a3 = int2x4(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            int2x4 b3 = int2x4(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            int2x4 r3 = int2x4(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_xor_wide_scalar()
+        {
+            int2x4 a0 = int2x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586);
+            int b0 = (493665894);
+            int2x4 r0 = int2x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int2x4 a1 = int2x4(1305234431, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978);
+            int b1 = (353786540);
+            int2x4 r1 = int2x4(1490686291, 1528187574, 1585863135, 309015380, 1534886006, 1913214449, 333543154, 57919030);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int2x4 a2 = int2x4(491079274, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736);
+            int b2 = (191750702);
+            int2x4 r2 = int2x4(371762244, 4897915, 852093491, 732592657, 763363694, 190966742, 1397197090, 1867453430);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int2x4 a3 = int2x4(447453839, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291);
+            int b3 = (890841598);
+            int2x4 r3 = int2x4(800240497, 610664066, 711808497, 714187902, 1735978412, 1929239075, 171965729, 427463573);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int2x4 b0 = int2x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737);
+            int2x4 r0 = int2x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1773918217);
+            int2x4 b1 = int2x4(1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937);
+            int2x4 r1 = int2x4(809875551, 777590045, 762148929, 497155858, 8071545, 440700667, 702609021, 2028559872);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1382343363);
+            int2x4 b2 = int2x4(939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481);
+            int2x4 r2 = int2x4(1704743464, 476745462, 1598742512, 1722301941, 1981778335, 1509285046, 19333242, 1884605034);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1813817520);
+            int2x4 b3 = int2x4(86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759);
+            int2x4 r3 = int2x4(1765145501, 465338881, 961174309, 1508358725, 916626445, 1734574159, 1183306712, 2052237431);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_left_shift()
+        {
+            int2x4 a0 = int2x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484);
+            int b0 = (1321149625);
+            int2x4 r0 = int2x4(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int2x4 a1 = int2x4(1200694230, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989);
+            int b1 = (1531607705);
+            int2x4 r1 = int2x4(-1409286144, -872415232, -1409286144, 1006632960, 1174405120, 503316480, -1677721600, -637534208);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int2x4 a2 = int2x4(2077023268, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278);
+            int b2 = (592678686);
+            int2x4 r2 = int2x4(0, -1073741824, -1073741824, -1073741824, 1073741824, 1073741824, 1073741824, -2147483648);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int2x4 a3 = int2x4(221147365, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688);
+            int b3 = (2084190583);
+            int2x4 r3 = int2x4(1920991232, -1342177280, -603979776, -134217728, -805306368, -310378496, 109051904, 1207959552);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_right_shift()
+        {
+            int2x4 a0 = int2x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998);
+            int b0 = (1266801540);
+            int2x4 r0 = int2x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int2x4 a1 = int2x4(572763124, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711);
+            int b1 = (506619530);
+            int2x4 r1 = int2x4(559338, 416804, 1983710, 685476, 896274, 556157, 181243, 1076292);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int2x4 a2 = int2x4(334005460, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760);
+            int b2 = (1624751550);
+            int2x4 r2 = int2x4(0, 0, 1, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int2x4 a3 = int2x4(348013684, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476);
+            int b3 = (1568185874);
+            int2x4 r3 = int2x4(1327, 2953, 6054, 2289, 112, 7175, 1343, 4442);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int2x4_operator_bitwise_not()
+        {
+            int2x4 a0 = int2x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856);
+            int2x4 r0 = int2x4(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857);
+            TestUtils.AreEqual(~a0, r0);
+
+            int2x4 a1 = int2x4(472965491, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466);
+            int2x4 r1 = int2x4(-472965492, -627580961, -2061524025, -753208489, -2097179284, -1303022494, -664744604, -1289372467);
+            TestUtils.AreEqual(~a1, r1);
+
+            int2x4 a2 = int2x4(1635981125, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942);
+            int2x4 r2 = int2x4(-1635981126, -1545651938, -717936458, -1284504688, -1342785386, -869629476, -2045854322, -1282546943);
+            TestUtils.AreEqual(~a2, r2);
+
+            int2x4 a3 = int2x4(1562433528, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039);
+            int2x4 r3 = int2x4(-1562433529, -1736570716, -508906059, -2060752881, -1867418757, -388530275, -695179853, -1766938040);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c14b2a079475b0b3ef5680e038c5d4877cc66a85
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt2x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 847ca3f6ecd472f43b9995db81c87807
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..97f7efaf635930723a41c7e63dfbc6eaf1f8c4bb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs
@@ -0,0 +1,1346 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt3
+    {
+        [TestCompiler]
+        public static void int3_zero()
+        {
+            TestUtils.AreEqual(int3.zero.x, 0);
+            TestUtils.AreEqual(int3.zero.y, 0);
+            TestUtils.AreEqual(int3.zero.z, 0);
+        }
+
+        [TestCompiler]
+        public static void int3_constructor()
+        {
+            int3 a = new int3(1, 2, 3);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+        }
+
+        [TestCompiler]
+        public static void int3_scalar_constructor()
+        {
+            int3 a = new int3(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+            TestUtils.AreEqual(a.z, 17);
+        }
+
+        [TestCompiler]
+        public static void int3_static_constructor()
+        {
+            int3 a = int3(1, 2, 3);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+        }
+
+        [TestCompiler]
+        public static void int3_static_scalar_constructor()
+        {
+            int3 a = int3(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+            TestUtils.AreEqual(a.z, 17);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_equal_wide_wide()
+        {
+            int3 a0 = int3(790229414, 970783976, 1428432738);
+            int3 b0 = int3(612337669, 1214209108, 2120643427);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3 a1 = int3(1578747135, 1733797753, 2001507228);
+            int3 b1 = int3(295461214, 1510890331, 1893316566);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3 a2 = int3(1446876437, 1777406370, 1426387268);
+            int3 b2 = int3(921816149, 1834958575, 1482011863);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3 a3 = int3(1809275021, 1843770816, 1172185222);
+            int3 b3 = int3(2062852792, 226398742, 770290735);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_equal_wide_scalar()
+        {
+            int3 a0 = int3(1211464300, 1921862607, 508076684);
+            int b0 = (746972502);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3 a1 = int3(1249127920, 746862310, 1733655277);
+            int b1 = (1394594555);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3 a2 = int3(1884008277, 795585660, 936027116);
+            int b2 = (1682018538);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3 a3 = int3(927605411, 1465584610, 585324157);
+            int b3 = (672785749);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int3 b0 = int3(233855098, 924242519, 1402948791);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (601381975);
+            int3 b1 = int3(2120518068, 629187703, 1971977031);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (47183124);
+            int3 b2 = int3(1061805787, 1009011238, 312511148);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1460673064);
+            int3 b3 = int3(737210539, 1737844479, 1892405453);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_not_equal_wide_wide()
+        {
+            int3 a0 = int3(1660932106, 982847023, 97046264);
+            int3 b0 = int3(107139049, 75478496, 2055495054);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3 a1 = int3(1739517447, 1253499180, 1830584069);
+            int3 b1 = int3(358586687, 942338347, 111564990);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3 a2 = int3(1841470429, 1397841646, 1770890135);
+            int3 b2 = int3(113811950, 948912488, 1080084121);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3 a3 = int3(1906548631, 169082967, 2099271786);
+            int3 b3 = int3(1400504872, 1032134499, 1061123400);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_not_equal_wide_scalar()
+        {
+            int3 a0 = int3(747758183, 1033001286, 1439973882);
+            int b0 = (248693828);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3 a1 = int3(2138928797, 1432672459, 950170763);
+            int b1 = (1197845089);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3 a2 = int3(238704450, 727205263, 1640688041);
+            int b2 = (2105962247);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3 a3 = int3(276313906, 791998981, 2035077187);
+            int b3 = (2126300423);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int3 b0 = int3(2037494727, 1989050616, 48833929);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (1897435904);
+            int3 b1 = int3(514354517, 1783749164, 364694471);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (754315072);
+            int3 b2 = int3(124108032, 1512967900, 1178825850);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1854793298);
+            int3 b3 = int3(50286949, 2100802631, 1640811853);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_wide_wide()
+        {
+            int3 a0 = int3(1182186063, 415538999, 1667335818);
+            int3 b0 = int3(524633529, 1032195686, 760723389);
+            bool3 r0 = bool3(false, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3 a1 = int3(1566618442, 1166180837, 639095188);
+            int3 b1 = int3(1505751409, 431962172, 1287906509);
+            bool3 r1 = bool3(false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3 a2 = int3(1080836365, 771119973, 928263233);
+            int3 b2 = int3(1560084663, 1450178202, 2066166337);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3 a3 = int3(789225474, 665243110, 1003542034);
+            int3 b3 = int3(1107069023, 1640077524, 2103263105);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_wide_scalar()
+        {
+            int3 a0 = int3(608447185, 818840405, 869219329);
+            int b0 = (1491216667);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3 a1 = int3(2080125385, 1361741203, 1667165786);
+            int b1 = (1214500548);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3 a2 = int3(1615392341, 469591900, 1247103789);
+            int b2 = (840091491);
+            bool3 r2 = bool3(false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3 a3 = int3(315321650, 1100560246, 933855388);
+            int b3 = (930950514);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int3 b0 = int3(282703327, 14370648, 1862117300);
+            bool3 r0 = bool3(false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1304793311);
+            int3 b1 = int3(826073259, 988910157, 445132446);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1139670255);
+            int3 b2 = int3(111349251, 1102440676, 112183144);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (1594415311);
+            int3 b3 = int3(1890019295, 2098715503, 608933527);
+            bool3 r3 = bool3(true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_wide_wide()
+        {
+            int3 a0 = int3(592884447, 2133928932, 918957182);
+            int3 b0 = int3(138737040, 192863971, 1700841444);
+            bool3 r0 = bool3(true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3 a1 = int3(1284069471, 194584707, 739120780);
+            int3 b1 = int3(1044631301, 1391589821, 730837695);
+            bool3 r1 = bool3(true, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3 a2 = int3(241654068, 1340158550, 2099542537);
+            int3 b2 = int3(253553987, 2078872742, 910845808);
+            bool3 r2 = bool3(false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3 a3 = int3(1182623667, 1399607274, 789301637);
+            int3 b3 = int3(976047676, 202633078, 1223618940);
+            bool3 r3 = bool3(true, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_wide_scalar()
+        {
+            int3 a0 = int3(1097138316, 211763648, 1883002501);
+            int b0 = (438688675);
+            bool3 r0 = bool3(true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3 a1 = int3(56406996, 1923456111, 1437755186);
+            int b1 = (43662641);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3 a2 = int3(1219010035, 304028799, 893125636);
+            int b2 = (2125058448);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3 a3 = int3(48044515, 1035679270, 577943770);
+            int b3 = (711945018);
+            bool3 r3 = bool3(false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int3 b0 = int3(599356784, 185671342, 1932327391);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (2025591013);
+            int3 b1 = int3(1257191721, 1312388500, 1443698859);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (779217735);
+            int3 b2 = int3(691047512, 741776730, 732565983);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (668302204);
+            int3 b3 = int3(1556466996, 858599525, 1896917159);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_equal_wide_wide()
+        {
+            int3 a0 = int3(1577248162, 2043073061, 1688380407);
+            int3 b0 = int3(903445031, 2108974565, 210822256);
+            bool3 r0 = bool3(false, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3 a1 = int3(176431985, 223299035, 1502802140);
+            int3 b1 = int3(1281704747, 453681718, 66138830);
+            bool3 r1 = bool3(true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3 a2 = int3(1691709825, 386789394, 117182003);
+            int3 b2 = int3(1229799377, 1620922595, 1715833766);
+            bool3 r2 = bool3(false, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3 a3 = int3(1665770435, 1958490731, 420032601);
+            int3 b3 = int3(1366430432, 13102000, 46919981);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_equal_wide_scalar()
+        {
+            int3 a0 = int3(1722165358, 1219858357, 860410743);
+            int b0 = (1688048545);
+            bool3 r0 = bool3(false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3 a1 = int3(411099660, 1963256951, 212084836);
+            int b1 = (348104022);
+            bool3 r1 = bool3(false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3 a2 = int3(58924407, 1745758438, 532949158);
+            int b2 = (1459242706);
+            bool3 r2 = bool3(true, false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3 a3 = int3(262559763, 1806172431, 2091514001);
+            int b3 = (690091301);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int3 b0 = int3(1181030049, 1787703989, 1729760948);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1816537388);
+            int3 b1 = int3(1359786460, 874999193, 1678863148);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (1711365839);
+            int3 b2 = int3(762067160, 11953554, 1131583906);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (1175393186);
+            int3 b3 = int3(1293698493, 48893340, 66196247);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_equal_wide_wide()
+        {
+            int3 a0 = int3(263000030, 744235661, 1893760267);
+            int3 b0 = int3(1395535146, 1178373944, 1237373760);
+            bool3 r0 = bool3(false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3 a1 = int3(237248, 1062370984, 1676977687);
+            int3 b1 = int3(1364855321, 600811864, 362060472);
+            bool3 r1 = bool3(false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3 a2 = int3(816766880, 1089431546, 1394493730);
+            int3 b2 = int3(290870624, 1839067862, 396958580);
+            bool3 r2 = bool3(true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3 a3 = int3(1176473380, 1193988637, 1703862455);
+            int3 b3 = int3(1336888643, 1019684398, 1697684196);
+            bool3 r3 = bool3(false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_equal_wide_scalar()
+        {
+            int3 a0 = int3(2112791350, 1043657935, 101764761);
+            int b0 = (1470533736);
+            bool3 r0 = bool3(true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3 a1 = int3(1529909067, 281734132, 1186600258);
+            int b1 = (556026890);
+            bool3 r1 = bool3(true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3 a2 = int3(815093894, 1604309397, 829548642);
+            int b2 = (609211196);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3 a3 = int3(244604867, 471843809, 1819986195);
+            int b3 = (1419295004);
+            bool3 r3 = bool3(false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int3 b0 = int3(1503244746, 861711266, 817773856);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (925984572);
+            int3 b1 = int3(571221723, 683686810, 118252990);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (1653952090);
+            int3 b2 = int3(1240253990, 1947039008, 1869136019);
+            bool3 r2 = bool3(true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (152012637);
+            int3 b3 = int3(1214546726, 917376832, 303549425);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_add_wide_wide()
+        {
+            int3 a0 = int3(2049228671, 1658660009, 491719392);
+            int3 b0 = int3(2088751567, 645762023, 306868786);
+            int3 r0 = int3(-156987058, -1990545264, 798588178);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3 a1 = int3(937013355, 81108663, 1063894558);
+            int3 b1 = int3(4360271, 506047997, 2094559874);
+            int3 r1 = int3(941373626, 587156660, -1136512864);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3 a2 = int3(86954702, 843159721, 698977704);
+            int3 b2 = int3(1634712736, 1601474440, 1586485231);
+            int3 r2 = int3(1721667438, -1850333135, -2009504361);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3 a3 = int3(192867135, 1683407172, 137301303);
+            int3 b3 = int3(908746788, 1812370320, 1247342357);
+            int3 r3 = int3(1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_add_wide_scalar()
+        {
+            int3 a0 = int3(2038218457, 134923711, 875689667);
+            int b0 = (2124409227);
+            int3 r0 = int3(-132339612, -2035634358, -1294868402);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3 a1 = int3(1338884463, 340490871, 1067888129);
+            int b1 = (997710928);
+            int3 r1 = int3(-1958371905, 1338201799, 2065599057);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3 a2 = int3(70433301, 1635971971, 1160398286);
+            int b2 = (2003021861);
+            int3 r2 = int3(2073455162, -655973464, -1131547149);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3 a3 = int3(85446202, 1239387100, 1497676888);
+            int b3 = (1068152966);
+            int3 r3 = int3(1153599168, -1987427230, -1729137442);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int3 b0 = int3(519908870, 851424292, 328314822);
+            int3 r0 = int3(911000948, 1242516370, 719406900);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (135622204);
+            int3 b1 = int3(740923360, 655394201, 1451896269);
+            int3 r1 = int3(876545564, 791016405, 1587518473);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1781697072);
+            int3 b2 = int3(996031825, 1557774949, 779774940);
+            int3 r2 = int3(-1517238399, -955495275, -1733495284);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1111541302);
+            int3 b3 = int3(783046445, 1130163944, 288279584);
+            int3 r3 = int3(1894587747, -2053262050, 1399820886);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_sub_wide_wide()
+        {
+            int3 a0 = int3(1353441118, 797269833, 659988112);
+            int3 b0 = int3(1332656812, 1827794007, 972557431);
+            int3 r0 = int3(20784306, -1030524174, -312569319);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3 a1 = int3(56022121, 365847472, 2062899435);
+            int3 b1 = int3(2078233689, 1508184327, 1372307701);
+            int3 r1 = int3(-2022211568, -1142336855, 690591734);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3 a2 = int3(1380988474, 799885138, 1306058185);
+            int3 b2 = int3(810327977, 936799885, 71562303);
+            int3 r2 = int3(570660497, -136914747, 1234495882);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3 a3 = int3(579775276, 1239163824, 344591081);
+            int3 b3 = int3(1418723328, 1971342989, 1226053395);
+            int3 r3 = int3(-838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_sub_wide_scalar()
+        {
+            int3 a0 = int3(1176369558, 1934521195, 309452150);
+            int b0 = (462232403);
+            int3 r0 = int3(714137155, 1472288792, -152780253);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3 a1 = int3(1417634074, 1306356714, 1502312334);
+            int b1 = (108910717);
+            int3 r1 = int3(1308723357, 1197445997, 1393401617);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3 a2 = int3(1451794815, 87530840, 1913724431);
+            int b2 = (281174200);
+            int3 r2 = int3(1170620615, -193643360, 1632550231);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3 a3 = int3(2041593336, 1119051448, 1590376732);
+            int b3 = (557239990);
+            int3 r3 = int3(1484353346, 561811458, 1033136742);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int3 b0 = int3(2022393810, 1612688515, 496689713);
+            int3 r0 = int3(-330859405, 78845890, 1194844692);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (887037586);
+            int3 b1 = int3(2097630964, 374934538, 939035482);
+            int3 r1 = int3(-1210593378, 512103048, -51997896);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (935242277);
+            int3 b2 = int3(1789300421, 264712893, 1231856067);
+            int3 r2 = int3(-854058144, 670529384, -296613790);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1818112748);
+            int3 b3 = int3(1428436109, 1258745460, 1077380396);
+            int3 r3 = int3(389676639, 559367288, 740732352);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mul_wide_wide()
+        {
+            int3 a0 = int3(245827027, 208934650, 1019478917);
+            int3 b0 = int3(759663997, 350129201, 477450108);
+            int3 r0 = int3(-632811769, 1402281434, 332447596);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3 a1 = int3(568231809, 877289039, 1585782440);
+            int3 b1 = int3(1635735015, 388710278, 757722665);
+            int3 r1 = int3(-1932977561, -1670918566, 1455036648);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3 a2 = int3(2111178729, 1186019069, 571481445);
+            int3 b2 = int3(1509388321, 1841703980, 1826369331);
+            int3 r2 = int3(2128344329, -594088068, -1654168033);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3 a3 = int3(1570087048, 629447153, 619383734);
+            int3 b3 = int3(1524322467, 1605207974, 428419155);
+            int3 r3 = int3(2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mul_wide_scalar()
+        {
+            int3 a0 = int3(1762033447, 465343930, 1570757881);
+            int b0 = (1476837906);
+            int3 r0 = int3(-1313177922, 1326807828, -2138555518);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3 a1 = int3(1326409563, 1356578909, 72749215);
+            int b1 = (1824319147);
+            int3 r1 = int3(-252064823, -236385249, -2127563723);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3 a2 = int3(154616909, 573770299, 1958912969);
+            int b2 = (975743632);
+            int3 r2 = int3(7966032, 414773040, 262642448);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3 a3 = int3(971327747, 1324050764, 660611671);
+            int b3 = (1818877398);
+            int3 r3 = int3(-1947361406, 1927061896, -1313812550);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int3 b0 = int3(1764461774, 657072478, 1459784358);
+            int3 r0 = int3(-950398648, -102049016, 1260585960);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1610646683);
+            int3 b1 = int3(1632058826, 868441654, 1408757883);
+            int3 r1 = int3(1644073294, 1407050418, -820115847);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (335917146);
+            int3 b2 = int3(2105124483, 1178393968, 1963904348);
+            int3 r2 = int3(1003330062, -1663903392, -2026933672);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (1409533767);
+            int3 b3 = int3(243286231, 1336308795, 517963367);
+            int3 r3 = int3(108928161, 875895133, -1837949039);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_div_wide_wide()
+        {
+            int3 a0 = int3(1590198532, 507812502, 126627032);
+            int3 b0 = int3(1434703236, 911965201, 390415521);
+            int3 r0 = int3(1, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3 a1 = int3(1058247011, 427387861, 290676154);
+            int3 b1 = int3(128746927, 525835375, 816946613);
+            int3 r1 = int3(8, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3 a2 = int3(1829594484, 1127868739, 499016351);
+            int3 b2 = int3(878264647, 146789678, 2089524057);
+            int3 r2 = int3(2, 7, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3 a3 = int3(1341209632, 134906097, 785470242);
+            int3 b3 = int3(254213018, 1916850021, 1737806518);
+            int3 r3 = int3(5, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_div_wide_scalar()
+        {
+            int3 a0 = int3(560951562, 1218680769, 375341724);
+            int b0 = (947861580);
+            int3 r0 = int3(0, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3 a1 = int3(1613542090, 1397425408, 1349573078);
+            int b1 = (1919409166);
+            int3 r1 = int3(0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3 a2 = int3(524526253, 495895326, 1515313790);
+            int b2 = (341995568);
+            int3 r2 = int3(1, 1, 4);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3 a3 = int3(1676971657, 2105094094, 1017891310);
+            int b3 = (2131487088);
+            int3 r3 = int3(0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int3 b0 = int3(187325733, 1594107378, 2016183849);
+            int3 r0 = int3(6, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (1589343709);
+            int3 b1 = int3(388768753, 1417077283, 1773486938);
+            int3 r1 = int3(4, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1154044032);
+            int3 b2 = int3(81831373, 1476877645, 653688843);
+            int3 r2 = int3(14, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (45756703);
+            int3 b3 = int3(631027637, 396671391, 784365696);
+            int3 r3 = int3(0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mod_wide_wide()
+        {
+            int3 a0 = int3(146150818, 1846543305, 1071447756);
+            int3 b0 = int3(983050390, 771341152, 942375212);
+            int3 r0 = int3(146150818, 303861001, 129072544);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3 a1 = int3(308965362, 659881575, 1002365460);
+            int3 b1 = int3(367361754, 749500619, 750718852);
+            int3 r1 = int3(308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3 a2 = int3(861198439, 1510617532, 778525078);
+            int3 b2 = int3(2095151755, 88438806, 769227442);
+            int3 r2 = int3(861198439, 7157830, 9297636);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3 a3 = int3(1458458044, 101987897, 1249565173);
+            int3 b3 = int3(647214624, 1026513788, 1544950956);
+            int3 r3 = int3(164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mod_wide_scalar()
+        {
+            int3 a0 = int3(164800505, 1062177828, 1898749675);
+            int b0 = (883951171);
+            int3 r0 = int3(164800505, 178226657, 130847333);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3 a1 = int3(1701653318, 19002208, 128329633);
+            int b1 = (820393245);
+            int3 r1 = int3(60866828, 19002208, 128329633);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3 a2 = int3(1464010899, 405208598, 1982762194);
+            int b2 = (896587769);
+            int3 r2 = int3(567423130, 405208598, 189586656);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3 a3 = int3(959236935, 172564850, 1540068445);
+            int b3 = (712321026);
+            int3 r3 = int3(246915909, 172564850, 115426393);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int3 b0 = int3(740000543, 1556450291, 1104736385);
+            int3 r0 = int3(242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (437976569);
+            int3 b1 = int3(1911837205, 1507212038, 1906405167);
+            int3 r1 = int3(437976569, 437976569, 437976569);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (247693265);
+            int3 b2 = int3(293460573, 1495295166, 873323603);
+            int3 r2 = int3(247693265, 247693265, 247693265);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (530681233);
+            int3 b3 = int3(1298102643, 2057984657, 1000742091);
+            int3 r3 = int3(530681233, 530681233, 530681233);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_plus()
+        {
+            int3 a0 = int3(1643476803, 907898539, 379615839);
+            int3 r0 = int3(1643476803, 907898539, 379615839);
+            TestUtils.AreEqual(+a0, r0);
+
+            int3 a1 = int3(1140483021, 1743199272, 1472881565);
+            int3 r1 = int3(1140483021, 1743199272, 1472881565);
+            TestUtils.AreEqual(+a1, r1);
+
+            int3 a2 = int3(339091479, 1287765427, 849339193);
+            int3 r2 = int3(339091479, 1287765427, 849339193);
+            TestUtils.AreEqual(+a2, r2);
+
+            int3 a3 = int3(174532915, 1566098441, 1145639744);
+            int3 r3 = int3(174532915, 1566098441, 1145639744);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_neg()
+        {
+            int3 a0 = int3(1955022112, 662160019, 370300775);
+            int3 r0 = int3(-1955022112, -662160019, -370300775);
+            TestUtils.AreEqual(-a0, r0);
+
+            int3 a1 = int3(2141283773, 28153593, 33894270);
+            int3 r1 = int3(-2141283773, -28153593, -33894270);
+            TestUtils.AreEqual(-a1, r1);
+
+            int3 a2 = int3(505708349, 1636274969, 694995093);
+            int3 r2 = int3(-505708349, -1636274969, -694995093);
+            TestUtils.AreEqual(-a2, r2);
+
+            int3 a3 = int3(1542206286, 243937487, 341522275);
+            int3 r3 = int3(-1542206286, -243937487, -341522275);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_prefix_inc()
+        {
+            int3 a0 = int3(864455342, 2035793213, 1275443862);
+            int3 r0 = int3(864455343, 2035793214, 1275443863);
+            TestUtils.AreEqual(++a0, r0);
+
+            int3 a1 = int3(971919915, 446210725, 395072276);
+            int3 r1 = int3(971919916, 446210726, 395072277);
+            TestUtils.AreEqual(++a1, r1);
+
+            int3 a2 = int3(115573442, 432884105, 1208161871);
+            int3 r2 = int3(115573443, 432884106, 1208161872);
+            TestUtils.AreEqual(++a2, r2);
+
+            int3 a3 = int3(1385544935, 831396561, 388229350);
+            int3 r3 = int3(1385544936, 831396562, 388229351);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_postfix_inc()
+        {
+            int3 a0 = int3(1751003569, 2063707595, 1500486291);
+            int3 r0 = int3(1751003569, 2063707595, 1500486291);
+            TestUtils.AreEqual(a0++, r0);
+
+            int3 a1 = int3(969189211, 2028651936, 1643023524);
+            int3 r1 = int3(969189211, 2028651936, 1643023524);
+            TestUtils.AreEqual(a1++, r1);
+
+            int3 a2 = int3(1190630527, 708474528, 177416855);
+            int3 r2 = int3(1190630527, 708474528, 177416855);
+            TestUtils.AreEqual(a2++, r2);
+
+            int3 a3 = int3(1524860667, 375284401, 1580130369);
+            int3 r3 = int3(1524860667, 375284401, 1580130369);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_prefix_dec()
+        {
+            int3 a0 = int3(200904609, 871077500, 968578728);
+            int3 r0 = int3(200904608, 871077499, 968578727);
+            TestUtils.AreEqual(--a0, r0);
+
+            int3 a1 = int3(638967721, 435367037, 1782514098);
+            int3 r1 = int3(638967720, 435367036, 1782514097);
+            TestUtils.AreEqual(--a1, r1);
+
+            int3 a2 = int3(1589827826, 596759698, 1699290403);
+            int3 r2 = int3(1589827825, 596759697, 1699290402);
+            TestUtils.AreEqual(--a2, r2);
+
+            int3 a3 = int3(1758478358, 71237375, 389120307);
+            int3 r3 = int3(1758478357, 71237374, 389120306);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_postfix_dec()
+        {
+            int3 a0 = int3(283970262, 1109329936, 1073216143);
+            int3 r0 = int3(283970262, 1109329936, 1073216143);
+            TestUtils.AreEqual(a0--, r0);
+
+            int3 a1 = int3(649439137, 1174104498, 484207852);
+            int3 r1 = int3(649439137, 1174104498, 484207852);
+            TestUtils.AreEqual(a1--, r1);
+
+            int3 a2 = int3(524156737, 2017728859, 802721301);
+            int3 r2 = int3(524156737, 2017728859, 802721301);
+            TestUtils.AreEqual(a2--, r2);
+
+            int3 a3 = int3(377162390, 1504625034, 590919177);
+            int3 r3 = int3(377162390, 1504625034, 590919177);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_and_wide_wide()
+        {
+            int3 a0 = int3(779935043, 1097962163, 1939593304);
+            int3 b0 = int3(307705143, 1710882162, 866836769);
+            int3 r0 = int3(39064835, 1097961522, 864731136);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3 a1 = int3(800599247, 952140918, 782792558);
+            int3 b1 = int3(532490608, 679371720, 1794035877);
+            int3 r1 = int3(263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3 a2 = int3(1608557706, 396446406, 2039894114);
+            int3 b2 = int3(1439832202, 519529812, 23633139);
+            int3 r2 = int3(1438646410, 379666500, 16781410);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3 a3 = int3(1286974642, 442394124, 1759739564);
+            int3 b3 = int3(1209152681, 646737179, 1255867027);
+            int3 r3 = int3(1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_and_wide_scalar()
+        {
+            int3 a0 = int3(443615469, 490057985, 2042441263);
+            int b0 = (93423598);
+            int3 r0 = int3(1114348, 85033216, 26281518);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3 a1 = int3(1524760558, 510212004, 1941875181);
+            int b1 = (1405175110);
+            int3 r1 = int3(1388397894, 306251012, 1400897860);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3 a2 = int3(1236735839, 428270198, 607982857);
+            int b2 = (1365509729);
+            int3 r2 = int3(1092879937, 285475424, 2360321);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3 a3 = int3(650270920, 814629680, 1862276471);
+            int b3 = (1249238550);
+            int3 r3 = int3(37771264, 279056, 1241519126);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int3 b0 = int3(420346723, 562416448, 1393127318);
+            int3 r0 = int3(547170, 18752, 1074284806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1560699552);
+            int3 b1 = int3(851218057, 703880958, 1159378889);
+            int3 r1 = int3(268698240, 151274144, 1157767808);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (2031211279);
+            int3 b2 = int3(1089518981, 270607307, 1349288930);
+            int3 r2 = int3(1074827525, 268501771, 1342210818);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (520199596);
+            int3 b3 = int3(1763483957, 1248975349, 236938635);
+            int3 r3 = int3(151028004, 167877028, 234947976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_or_wide_wide()
+        {
+            int3 a0 = int3(1731159103, 659068416, 382702471);
+            int3 b0 = int3(1583847161, 692672727, 1161585489);
+            int3 r0 = int3(2138044159, 793370327, 1476391895);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3 a1 = int3(1821032196, 1565773438, 1004000514);
+            int3 b1 = int3(1756207130, 1321374429, 1287357212);
+            int3 r1 = int3(1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3 a2 = int3(948501377, 600951835, 669346222);
+            int3 b2 = int3(2075767170, 1273513430, 1610830169);
+            int3 r2 = int3(2075786115, 1811533279, 1743223295);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3 a3 = int3(396691477, 2108560248, 2117522137);
+            int3 b3 = int3(1316929125, 511625048, 573925879);
+            int3 r3 = int3(1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_or_wide_scalar()
+        {
+            int3 a0 = int3(961259683, 471103264, 1733389229);
+            int b0 = (1666102508);
+            int3 r0 = int3(2068823279, 2136930284, 1734344685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3 a1 = int3(1591585258, 1148351449, 1048929715);
+            int b1 = (386953869);
+            int3 r1 = int3(1608383471, 1467118557, 1066760127);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3 a2 = int3(1814263250, 1637162093, 1227888278);
+            int b2 = (860336789);
+            int3 r2 = int3(2137520087, 1943518973, 2071443095);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3 a3 = int3(774029856, 1179087439, 797240690);
+            int b3 = (879300408);
+            int3 r3 = int3(1047252792, 1987018623, 1072557946);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int3 b0 = int3(1212928242, 1614462616, 936937728);
+            int3 r0 = int3(1213978111, 1752940445, 2145094925);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (764766995);
+            int3 b1 = int3(306352095, 574719481, 1283571271);
+            int3 r1 = int3(1071116255, 802549755, 1838546775);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (2109131012);
+            int3 b2 = int3(979469710, 1348323481, 1407542578);
+            int3 r2 = int3(2146946446, 2113915293, 2146954550);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (697517649);
+            int3 b3 = int3(1059093741, 627815046, 418822515);
+            int3 r3 = int3(1068728061, 771487447, 972554099);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_xor_wide_wide()
+        {
+            int3 a0 = int3(1556324760, 207002929, 1843444873);
+            int3 b0 = int3(1054997548, 1523759632, 251164872);
+            int3 r0 = int3(1646419380, 1451501345, 1662567489);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3 a1 = int3(1632079131, 1460334334, 1607815585);
+            int3 b1 = int3(110472397, 384031112, 1109163205);
+            int3 r1 = int3(1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3 a2 = int3(220623650, 38668553, 47193340);
+            int3 b2 = int3(535118981, 179106262, 1523031711);
+            int3 r2 = int3(314783655, 149092575, 1477935715);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3 a3 = int3(643663548, 1371932564, 94957188);
+            int3 b3 = int3(1713313372, 1294118730, 520360641);
+            int3 r3 = int3(1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_xor_wide_scalar()
+        {
+            int3 a0 = int3(2124666952, 177397845, 574879617);
+            int b0 = (493665894);
+            int3 r0 = int3(1674536494, 402546227, 1060063719);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3 a1 = int3(1937385541, 213863690, 535061373);
+            int b1 = (1136545648);
+            int3 r1 = int3(818177845, 1325466234, 1549413389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3 a2 = int3(289301586, 353786540, 1308626970);
+            int b2 = (1305234431);
+            int3 r2 = int3(1559375789, 1490686291, 63724517);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3 a3 = int3(1267729267, 1315625690, 1730088797);
+            int b3 = (125659640);
+            int3 r3 = int3(1290627723, 1226289954, 1617061541);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int3 b0 = int3(1077599928, 884741329, 212164516);
+            int3 r0 = int3(217506340, 2020616269, 1080648504);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1585020328);
+            int3 b1 = int3(152985454, 1775851275, 1416249064);
+            int3 r1 = int3(1466376902, 933243555, 169034560);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1309317737);
+            int3 b2 = int3(1773918217, 1509843030, 1206045972);
+            int3 r2 = int3(665928288, 401930815, 166221693);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1154916424);
+            int3 b3 = int3(1947871003, 1774252400, 1946113778);
+            int3 r3 = int3(818710355, 756437304, 925497018);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_left_shift()
+        {
+            int3 a0 = int3(197771193, 622182602, 1283988958);
+            int b0 = (1321149625);
+            int3 r0 = int3(1912602624, -1811939328, -1140850688);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int3 a1 = int3(1327917304, 432425717, 870301196);
+            int b1 = (473415985);
+            int3 r1 = int3(-772800512, -1779826688, 2081947648);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int3 a2 = int3(2058433484, 1531607705, 1360008038);
+            int b2 = (1200694230);
+            int3 r2 = int3(-218103808, -1505755136, -645922816);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int3 a3 = int3(1008296534, 1079614371, 35667343);
+            int b3 = (1447702302);
+            int3 r3 = int3(-2147483648, -1073741824, -1073741824);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_right_shift()
+        {
+            int3 a0 = int3(548167301, 1161338299, 1617625829);
+            int b0 = (1266801540);
+            int3 r0 = int3(34260456, 72583643, 101101614);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int3 a1 = int3(1860731847, 196552656, 770466193);
+            int b1 = (713958715);
+            int3 r1 = int3(13, 1, 5);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int3 a2 = int3(1265099998, 506619530, 426807581);
+            int b2 = (572763124);
+            int3 r2 = int3(1206, 483, 407);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int3 a3 = int3(2031319045, 917785020, 569504877);
+            int b3 = (701927980);
+            int3 r3 = int3(495927, 224068, 139039);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_operator_bitwise_not()
+        {
+            int3 a0 = int3(1403358969, 831360921, 2088190243);
+            int3 r0 = int3(-1403358970, -831360922, -2088190244);
+            TestUtils.AreEqual(~a0, r0);
+
+            int3 a1 = int3(976721016, 308994339, 1935567517);
+            int3 r1 = int3(-976721017, -308994340, -1935567518);
+            TestUtils.AreEqual(~a1, r1);
+
+            int3 a2 = int3(1420884856, 771711426, 627580960);
+            int3 r2 = int3(-1420884857, -771711427, -627580961);
+            TestUtils.AreEqual(~a2, r2);
+
+            int3 a3 = int3(2061524024, 2097179283, 1303022493);
+            int3 r3 = int3(-2061524025, -2097179284, -1303022494);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3_shuffle_result_1()
+        {
+            int3 a = int3(0, 1, 2);
+            int3 b = int3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ), (5));
+        }
+
+        [TestCompiler]
+        public static void int3_shuffle_result_2()
+        {
+            int3 a = int3(0, 1, 2);
+            int3 b = int3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), int2(4, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), int2(4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), int2(1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), int2(5, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY), int2(5, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), int2(1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftZ), int2(3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), int2(5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), int2(5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), int2(4, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), int2(4, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), int2(5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), int2(4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY), int2(5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), int2(3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), int2(1, 2));
+        }
+
+        [TestCompiler]
+        public static void int3_shuffle_result_3()
+        {
+            int3 a = int3(0, 1, 2);
+            int3 b = int3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.RightX), int3(1, 5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), int3(4, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX), int3(2, 5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY), int3(4, 0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.LeftZ), int3(5, 4, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.LeftY), int3(2, 0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightX), int3(2, 4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftY, ShuffleComponent.RightZ), int3(2, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ), int3(4, 4, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), int3(4, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), int3(5, 5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightX), int3(5, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightZ), int3(4, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightY), int3(2, 3, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), int3(4, 0, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ), int3(4, 0, 5));
+        }
+
+        [TestCompiler]
+        public static void int3_shuffle_result_4()
+        {
+            int3 a = int3(0, 1, 2);
+            int3 b = int3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY), int4(1, 2, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightY), int4(4, 2, 5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.LeftY), int4(4, 4, 5, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int4(3, 3, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), int4(4, 1, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightZ), int4(3, 4, 3, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightZ), int4(1, 5, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), int4(4, 0, 0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightZ, ShuffleComponent.LeftZ, ShuffleComponent.LeftX), int4(3, 5, 2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), int4(4, 3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), int4(0, 2, 5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.RightZ), int4(1, 4, 5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), int4(2, 3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), int4(3, 0, 1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(5, 3, 0, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(2, 5, 0, 4));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..03b32ecc296a4d26dc8d06e78942c0e6b4e7a01c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 749525b6f2a189a42bddcde8b3f6a88e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..f7889dd7e285762b77ce4329fef0f5dc18abcacc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs
@@ -0,0 +1,1227 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt3x2
+    {
+        [TestCompiler]
+        public static void int3x2_zero()
+        {
+            TestUtils.AreEqual(int3x2.zero.c0.x, 0);
+            TestUtils.AreEqual(int3x2.zero.c0.y, 0);
+            TestUtils.AreEqual(int3x2.zero.c0.z, 0);
+            TestUtils.AreEqual(int3x2.zero.c1.x, 0);
+            TestUtils.AreEqual(int3x2.zero.c1.y, 0);
+            TestUtils.AreEqual(int3x2.zero.c1.z, 0);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_equal_wide_wide()
+        {
+            int3x2 a0 = int3x2(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228);
+            int3x2 b0 = int3x2(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x2 a1 = int3x2(1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            int3x2 b1 = int3x2(921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x2 a2 = int3x2(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            int3x2 b2 = int3x2(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x2 a3 = int3x2(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int3x2 b3 = int3x2(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_equal_wide_scalar()
+        {
+            int3x2 a0 = int3x2(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310);
+            int b0 = (746972502);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x2 a1 = int3x2(1733655277, 1682018538, 795585660, 936027116, 927605411, 672785749);
+            int b1 = (1884008277);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x2 a2 = int3x2(1465584610, 404448210, 969511077, 442746747, 1772925698, 1884034177);
+            int b2 = (585324157);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x2 a3 = int3x2(451512860, 1370577708, 597010220, 1249636005, 211986678, 1305479811);
+            int b3 = (425476075);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int3x2 b0 = int3x2(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1971977031);
+            int3x2 b1 = int3x2(47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (1737844479);
+            int3x2 b2 = int3x2(1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (559824292);
+            int3x2 b3 = int3x2(1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_not_equal_wide_wide()
+        {
+            int3x2 a0 = int3x2(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069);
+            int3x2 b0 = int3x2(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x2 a1 = int3x2(1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            int3x2 b1 = int3x2(113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x2 a2 = int3x2(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            int3x2 b2 = int3x2(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x2 a3 = int3x2(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int3x2 b3 = int3x2(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_not_equal_wide_scalar()
+        {
+            int3x2 a0 = int3x2(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459);
+            int b0 = (248693828);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x2 a1 = int3x2(950170763, 2105962247, 727205263, 1640688041, 276313906, 2126300423);
+            int b1 = (238704450);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x2 a2 = int3x2(791998981, 1171827730, 1412347883, 1622176923, 768370497, 1072798259);
+            int b2 = (2035077187);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x2 a3 = int3x2(1808712713, 1582645163, 1876273820, 90244766, 30493685, 904014575);
+            int b3 = (1497830076);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int3x2 b0 = int3x2(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (364694471);
+            int3x2 b1 = int3x2(754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (2100802631);
+            int3x2 b2 = int3x2(1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1041416160);
+            int3x2 b3 = int3x2(356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_wide_wide()
+        {
+            int3x2 a0 = int3x2(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188);
+            int3x2 b0 = int3x2(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509);
+            bool3x2 r0 = bool3x2(false, true, false, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x2 a1 = int3x2(1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            int3x2 b1 = int3x2(1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x2 a2 = int3x2(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            int3x2 b2 = int3x2(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x2 a3 = int3x2(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int3x2 b3 = int3x2(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool3x2 r3 = bool3x2(true, true, false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_wide_scalar()
+        {
+            int3x2 a0 = int3x2(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203);
+            int b0 = (1491216667);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x2 a1 = int3x2(1667165786, 840091491, 469591900, 1247103789, 315321650, 930950514);
+            int b1 = (1615392341);
+            bool3x2 r1 = bool3x2(false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x2 a2 = int3x2(1100560246, 908563901, 1127696709, 1286331950, 380753337, 971148054);
+            int b2 = (933855388);
+            bool3x2 r2 = bool3x2(false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x2 a3 = int3x2(1827886929, 1579735991, 689044913, 1960894027, 371987110, 867559111);
+            int b3 = (1056649851);
+            bool3x2 r3 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int3x2 b0 = int3x2(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157);
+            bool3x2 r0 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (445132446);
+            int3x2 b1 = int3x2(1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (2098715503);
+            int3x2 b2 = int3x2(608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (874278078);
+            int3x2 b3 = int3x2(1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911);
+            bool3x2 r3 = bool3x2(true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_wide_wide()
+        {
+            int3x2 a0 = int3x2(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780);
+            int3x2 b0 = int3x2(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695);
+            bool3x2 r0 = bool3x2(true, true, false, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x2 a1 = int3x2(241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            int3x2 b1 = int3x2(253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool3x2 r1 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x2 a2 = int3x2(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            int3x2 b2 = int3x2(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool3x2 r2 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x2 a3 = int3x2(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int3x2 b3 = int3x2(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool3x2 r3 = bool3x2(false, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_wide_scalar()
+        {
+            int3x2 a0 = int3x2(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111);
+            int b0 = (438688675);
+            bool3x2 r0 = bool3x2(true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x2 a1 = int3x2(1437755186, 2125058448, 304028799, 893125636, 48044515, 711945018);
+            int b1 = (1219010035);
+            bool3x2 r1 = bool3x2(true, true, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x2 a2 = int3x2(1035679270, 572743717, 1016617211, 2063134811, 1577403353, 64009107);
+            int b2 = (577943770);
+            bool3x2 r2 = bool3x2(true, false, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x2 a3 = int3x2(1462961460, 3715845, 689362811, 263973424, 1045140419, 1058332184);
+            int b3 = (1143565920);
+            bool3x2 r3 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int3x2 b0 = int3x2(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1443698859);
+            int3x2 b1 = int3x2(779217735, 691047512, 741776730, 732565983, 668302204, 1556466996);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (858599525);
+            int3x2 b2 = int3x2(1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345);
+            bool3x2 r2 = bool3x2(false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (299897686);
+            int3x2 b3 = int3x2(632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_equal_wide_wide()
+        {
+            int3x2 a0 = int3x2(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140);
+            int3x2 b0 = int3x2(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830);
+            bool3x2 r0 = bool3x2(false, true, false, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x2 a1 = int3x2(1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            int3x2 b1 = int3x2(1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool3x2 r1 = bool3x2(false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x2 a2 = int3x2(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            int3x2 b2 = int3x2(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x2 a3 = int3x2(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int3x2 b3 = int3x2(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool3x2 r3 = bool3x2(true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_equal_wide_scalar()
+        {
+            int3x2 a0 = int3x2(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951);
+            int b0 = (1688048545);
+            bool3x2 r0 = bool3x2(false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x2 a1 = int3x2(212084836, 1459242706, 1745758438, 532949158, 262559763, 690091301);
+            int b1 = (58924407);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x2 a2 = int3x2(1806172431, 1857173043, 1617221948, 2017733017, 804204255, 981729559);
+            int b2 = (2091514001);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x2 a3 = int3x2(2032949254, 2079225209, 26179915, 238796519, 1917813750, 1258115260);
+            int b3 = (910922522);
+            bool3x2 r3 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int3x2 b0 = int3x2(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1678863148);
+            int3x2 b1 = int3x2(1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493);
+            bool3x2 r1 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (48893340);
+            int3x2 b2 = int3x2(66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (117849810);
+            int3x2 b3 = int3x2(1348693584, 105489302, 259034238, 530713566, 601413850, 830430286);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_equal_wide_wide()
+        {
+            int3x2 a0 = int3x2(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687);
+            int3x2 b0 = int3x2(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472);
+            bool3x2 r0 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x2 a1 = int3x2(816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            int3x2 b1 = int3x2(290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x2 a2 = int3x2(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            int3x2 b2 = int3x2(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool3x2 r2 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x2 a3 = int3x2(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int3x2 b3 = int3x2(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool3x2 r3 = bool3x2(false, true, false, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_equal_wide_scalar()
+        {
+            int3x2 a0 = int3x2(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132);
+            int b0 = (1470533736);
+            bool3x2 r0 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x2 a1 = int3x2(1186600258, 609211196, 1604309397, 829548642, 244604867, 1419295004);
+            int b1 = (815093894);
+            bool3x2 r1 = bool3x2(true, false, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x2 a2 = int3x2(471843809, 1460027917, 1646290021, 196833647, 1596738181, 1905036391);
+            int b2 = (1819986195);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x2 a3 = int3x2(1771391775, 370941146, 440219668, 1607345862, 1449142607, 1223010129);
+            int b3 = (1584946560);
+            bool3x2 r3 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int3x2 b0 = int3x2(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (118252990);
+            int3x2 b1 = int3x2(1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (917376832);
+            int3x2 b2 = int3x2(303549425, 2111728811, 945321577, 173706579, 625318949, 519443238);
+            bool3x2 r2 = bool3x2(true, false, false, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (1583588379);
+            int3x2 b3 = int3x2(1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_add_wide_wide()
+        {
+            int3x2 a0 = int3x2(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558);
+            int3x2 b0 = int3x2(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874);
+            int3x2 r0 = int3x2(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x2 a1 = int3x2(86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            int3x2 b1 = int3x2(1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            int3x2 r1 = int3x2(1721667438, -1850333135, -2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x2 a2 = int3x2(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            int3x2 b2 = int3x2(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            int3x2 r2 = int3x2(-147610603, 749502583, 623052937, -1181627673, -2116725070, -1148541136);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x2 a3 = int3x2(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int3x2 b3 = int3x2(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int3x2 r3 = int3x2(1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_add_wide_scalar()
+        {
+            int3x2 a0 = int3x2(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871);
+            int b0 = (2124409227);
+            int3x2 r0 = int3x2(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x2 a1 = int3x2(1067888129, 2003021861, 1635971971, 1160398286, 85446202, 1068152966);
+            int b1 = (70433301);
+            int3x2 r1 = int3x2(1138321430, 2073455162, 1706405272, 1230831587, 155879503, 1138586267);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x2 a2 = int3x2(1239387100, 1727477485, 1095438654, 756559204, 1818718931, 658923552);
+            int b2 = (1497676888);
+            int3x2 r2 = int3x2(-1557903308, -1069812923, -1701851754, -2040731204, -978571477, -2138366856);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x2 a3 = int3x2(1610518921, 692843300, 1068593469, 1704776233, 577782260, 736972565);
+            int b3 = (1585755398);
+            int3x2 r3 = int3x2(-1098692977, -2016368598, -1640618429, -1004435665, -2131429638, -1972239333);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int3x2 b0 = int3x2(519908870, 851424292, 328314822, 135622204, 740923360, 655394201);
+            int3x2 r0 = int3x2(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (1451896269);
+            int3x2 b1 = int3x2(1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445);
+            int3x2 r1 = int3x2(-1061373955, -1847039202, -1285296078, -2063296087, -1731529725, -2060024582);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1130163944);
+            int3x2 b2 = int3x2(288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965);
+            int3x2 r2 = int3x2(1418443528, -1767119491, -1528219863, 1803427283, -1695502478, 1145019909);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1116636999);
+            int3x2 b3 = int3x2(1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835);
+            int3x2 r3 = int3x2(-1689466997, -1577339411, 1307288300, -1870870529, 2036722838, -1096100462);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_sub_wide_wide()
+        {
+            int3x2 a0 = int3x2(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435);
+            int3x2 b0 = int3x2(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701);
+            int3x2 r0 = int3x2(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x2 a1 = int3x2(1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            int3x2 b1 = int3x2(810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            int3x2 r1 = int3x2(570660497, -136914747, 1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x2 a2 = int3x2(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            int3x2 b2 = int3x2(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            int3x2 r2 = int3x2(-50205903, -930193352, 120810088, 929308315, -624402009, -165899077);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x2 a3 = int3x2(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int3x2 b3 = int3x2(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int3x2 r3 = int3x2(-728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_sub_wide_scalar()
+        {
+            int3x2 a0 = int3x2(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714);
+            int b0 = (462232403);
+            int3x2 r0 = int3x2(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x2 a1 = int3x2(1502312334, 281174200, 87530840, 1913724431, 2041593336, 557239990);
+            int b1 = (1451794815);
+            int3x2 r1 = int3x2(50517519, -1170620615, -1364263975, 461929616, 589798521, -894554825);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x2 a2 = int3x2(1119051448, 819090189, 816382635, 815920639, 1829033117, 1792801932);
+            int b2 = (1590376732);
+            int3x2 r2 = int3x2(-471325284, -771286543, -773994097, -774456093, 238656385, 202425200);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x2 a3 = int3x2(1113440549, 1277257189, 2092779398, 642236742, 1605250794, 819644478);
+            int b3 = (1418937976);
+            int3x2 r3 = int3x2(-305497427, -141680787, 673841422, -776701234, 186312818, -599293498);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int3x2 b0 = int3x2(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538);
+            int3x2 r0 = int3x2(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (939035482);
+            int3x2 b1 = int3x2(935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109);
+            int3x2 r1 = int3x2(3793205, -850264939, 674322589, -292820585, -879077266, -489400627);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (1258745460);
+            int3x2 b2 = int3x2(1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918);
+            int3x2 r2 = int3x2(181365064, -71977259, 740633631, 291616931, 914079206, 176477542);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (907866696);
+            int3x2 b3 = int3x2(1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777);
+            int3x2 r3 = int3x2(-909018427, 447526128, -54287802, 350753235, -793350013, -1072232081);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mul_wide_wide()
+        {
+            int3x2 a0 = int3x2(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440);
+            int3x2 b0 = int3x2(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665);
+            int3x2 r0 = int3x2(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x2 a1 = int3x2(2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            int3x2 b1 = int3x2(1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            int3x2 r1 = int3x2(2128344329, -594088068, -1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x2 a2 = int3x2(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            int3x2 b2 = int3x2(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            int3x2 r2 = int3x2(990589280, -938173952, -1341723466, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x2 a3 = int3x2(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int3x2 b3 = int3x2(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int3x2 r3 = int3x2(1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mul_wide_scalar()
+        {
+            int3x2 a0 = int3x2(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909);
+            int b0 = (1476837906);
+            int3x2 r0 = int3x2(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x2 a1 = int3x2(72749215, 975743632, 573770299, 1958912969, 971327747, 1818877398);
+            int b1 = (154616909);
+            int3x2 r1 = int3x2(1400257491, 7966032, 499040191, 322676597, 469811687, -373386914);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x2 a2 = int3x2(1324050764, 1279757657, 391009467, 1186856590, 890343818, 800117742);
+            int b2 = (660611671);
+            int3x2 r2 = int3x2(645718228, -42542273, -1778409075, 1570790978, -133379610, 1820172770);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x2 a3 = int3x2(606927173, 1688964615, 1439447294, 387721300, 1192501703, 1613845584);
+            int b3 = (1338014500);
+            int3x2 r3 = int3x2(-254331724, 1134384636, 1352273336, -229242928, 1766808828, 645024576);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int3x2 b0 = int3x2(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654);
+            int3x2 r0 = int3x2(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1408757883);
+            int3x2 b1 = int3x2(335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231);
+            int3x2 r1 = int3x2(1223039806, 1995624689, -974691120, 375843636, 858017565, 2027534157);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1336308795);
+            int3x2 b2 = int3x2(517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700);
+            int3x2 r2 = int3x2(580046269, -997870016, -325015397, 831291671, -1034573003, -1254339924);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (677771573);
+            int3x2 b3 = int3x2(2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236);
+            int3x2 r3 = int3x2(-125843839, 1435043573, 698030233, 9173379, -824638806, 113055164);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_div_wide_wide()
+        {
+            int3x2 a0 = int3x2(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154);
+            int3x2 b0 = int3x2(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613);
+            int3x2 r0 = int3x2(1, 0, 0, 8, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x2 a1 = int3x2(1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            int3x2 b1 = int3x2(878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            int3x2 r1 = int3x2(2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x2 a2 = int3x2(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            int3x2 b2 = int3x2(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            int3x2 r2 = int3x2(0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x2 a3 = int3x2(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int3x2 b3 = int3x2(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int3x2 r3 = int3x2(0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_div_wide_scalar()
+        {
+            int3x2 a0 = int3x2(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408);
+            int b0 = (947861580);
+            int3x2 r0 = int3x2(0, 1, 0, 1, 2, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x2 a1 = int3x2(1349573078, 341995568, 495895326, 1515313790, 1676971657, 2131487088);
+            int b1 = (524526253);
+            int3x2 r1 = int3x2(2, 0, 0, 2, 3, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x2 a2 = int3x2(2105094094, 542666029, 1646044372, 1447236569, 107215658, 19616726);
+            int b2 = (1017891310);
+            int3x2 r2 = int3x2(2, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x2 a3 = int3x2(896899915, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864);
+            int b3 = (707389627);
+            int3x2 r3 = int3x2(1, 1, 2, 2, 2, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int3x2 b0 = int3x2(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283);
+            int3x2 r0 = int3x2(6, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (1773486938);
+            int3x2 b1 = int3x2(1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637);
+            int3x2 r1 = int3x2(1, 21, 1, 2, 38, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (396671391);
+            int3x2 b2 = int3x2(784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453);
+            int3x2 r2 = int3x2(0, 0, 0, 0, 1, 8);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (1796936382);
+            int3x2 b3 = int3x2(1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083);
+            int3x2 r3 = int3x2(1, 1, 0, 2, 1, 5);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mod_wide_wide()
+        {
+            int3x2 a0 = int3x2(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460);
+            int3x2 b0 = int3x2(983050390, 771341152, 942375212, 367361754, 749500619, 750718852);
+            int3x2 r0 = int3x2(146150818, 303861001, 129072544, 308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x2 a1 = int3x2(861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            int3x2 b1 = int3x2(2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            int3x2 r1 = int3x2(861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x2 a2 = int3x2(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            int3x2 b2 = int3x2(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            int3x2 r2 = int3x2(137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x2 a3 = int3x2(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int3x2 b3 = int3x2(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int3x2 r3 = int3x2(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mod_wide_scalar()
+        {
+            int3x2 a0 = int3x2(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208);
+            int b0 = (883951171);
+            int3x2 r0 = int3x2(164800505, 178226657, 130847333, 817702147, 820393245, 19002208);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x2 a1 = int3x2(128329633, 896587769, 405208598, 1982762194, 959236935, 712321026);
+            int b1 = (1464010899);
+            int3x2 r1 = int3x2(128329633, 896587769, 405208598, 518751295, 959236935, 712321026);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x2 a2 = int3x2(172564850, 1085897743, 1607489717, 165478511, 647846716, 915707999);
+            int b2 = (1540068445);
+            int3x2 r2 = int3x2(172564850, 1085897743, 67421272, 165478511, 647846716, 915707999);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x2 a3 = int3x2(1602830401, 1084934806, 488509689, 2087820912, 377501313, 1778384846);
+            int b3 = (928191283);
+            int3x2 r3 = int3x2(674639118, 156743523, 488509689, 231438346, 377501313, 850193563);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int3x2 b0 = int3x2(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038);
+            int3x2 r0 = int3x2(242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1906405167);
+            int3x2 b1 = int3x2(247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643);
+            int3x2 r1 = int3x2(172552312, 145641729, 411110001, 159757961, 314361468, 608302524);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (2057984657);
+            int3x2 b2 = int3x2(1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997);
+            int3x2 r2 = int3x2(56500475, 596612526, 198242315, 463615283, 414206973, 974791660);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (840114986);
+            int3x2 b3 = int3x2(1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061);
+            int3x2 r3 = int3x2(840114986, 224955022, 840114986, 217454, 840114986, 17224681);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_plus()
+        {
+            int3x2 a0 = int3x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            int3x2 r0 = int3x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            TestUtils.AreEqual(+a0, r0);
+
+            int3x2 a1 = int3x2(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            int3x2 r1 = int3x2(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            TestUtils.AreEqual(+a1, r1);
+
+            int3x2 a2 = int3x2(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            int3x2 r2 = int3x2(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            TestUtils.AreEqual(+a2, r2);
+
+            int3x2 a3 = int3x2(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            int3x2 r3 = int3x2(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_neg()
+        {
+            int3x2 a0 = int3x2(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593);
+            int3x2 r0 = int3x2(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593);
+            TestUtils.AreEqual(-a0, r0);
+
+            int3x2 a1 = int3x2(33894270, 1115028238, 1636274969, 694995093, 1542206286, 213087293);
+            int3x2 r1 = int3x2(-33894270, -1115028238, -1636274969, -694995093, -1542206286, -213087293);
+            TestUtils.AreEqual(-a1, r1);
+
+            int3x2 a2 = int3x2(243937487, 841085242, 574159094, 1687250035, 2057919693, 1175014732);
+            int3x2 r2 = int3x2(-243937487, -841085242, -574159094, -1687250035, -2057919693, -1175014732);
+            TestUtils.AreEqual(-a2, r2);
+
+            int3x2 a3 = int3x2(1259809073, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454);
+            int3x2 r3 = int3x2(-1259809073, -1190569920, -2047955772, -2120729864, -1440774928, -1485596454);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_prefix_inc()
+        {
+            int3x2 a0 = int3x2(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725);
+            int3x2 r0 = int3x2(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726);
+            TestUtils.AreEqual(++a0, r0);
+
+            int3x2 a1 = int3x2(395072276, 913293639, 432884105, 1208161871, 1385544935, 1835605516);
+            int3x2 r1 = int3x2(395072277, 913293640, 432884106, 1208161872, 1385544936, 1835605517);
+            TestUtils.AreEqual(++a1, r1);
+
+            int3x2 a2 = int3x2(831396561, 696475402, 1786514683, 993189311, 752093909, 1622410417);
+            int3x2 r2 = int3x2(831396562, 696475403, 1786514684, 993189312, 752093910, 1622410418);
+            TestUtils.AreEqual(++a2, r2);
+
+            int3x2 a3 = int3x2(1398865015, 1705625817, 609525897, 172599489, 504806865, 519296647);
+            int3x2 r3 = int3x2(1398865016, 1705625818, 609525898, 172599490, 504806866, 519296648);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_postfix_inc()
+        {
+            int3x2 a0 = int3x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            int3x2 r0 = int3x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            TestUtils.AreEqual(a0++, r0);
+
+            int3x2 a1 = int3x2(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            int3x2 r1 = int3x2(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            TestUtils.AreEqual(a1++, r1);
+
+            int3x2 a2 = int3x2(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            int3x2 r2 = int3x2(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            TestUtils.AreEqual(a2++, r2);
+
+            int3x2 a3 = int3x2(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            int3x2 r3 = int3x2(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_prefix_dec()
+        {
+            int3x2 a0 = int3x2(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037);
+            int3x2 r0 = int3x2(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036);
+            TestUtils.AreEqual(--a0, r0);
+
+            int3x2 a1 = int3x2(1782514098, 1434377580, 596759698, 1699290403, 1758478358, 1914114460);
+            int3x2 r1 = int3x2(1782514097, 1434377579, 596759697, 1699290402, 1758478357, 1914114459);
+            TestUtils.AreEqual(--a1, r1);
+
+            int3x2 a2 = int3x2(71237375, 1022184392, 1310293956, 356565557, 18299409, 906734601);
+            int3x2 r2 = int3x2(71237374, 1022184391, 1310293955, 356565556, 18299408, 906734600);
+            TestUtils.AreEqual(--a2, r2);
+
+            int3x2 a3 = int3x2(799006218, 1040798388, 1469596990, 1719228297, 220897829, 1454322707);
+            int3x2 r3 = int3x2(799006217, 1040798387, 1469596989, 1719228296, 220897828, 1454322706);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_postfix_dec()
+        {
+            int3x2 a0 = int3x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            int3x2 r0 = int3x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            TestUtils.AreEqual(a0--, r0);
+
+            int3x2 a1 = int3x2(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            int3x2 r1 = int3x2(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            TestUtils.AreEqual(a1--, r1);
+
+            int3x2 a2 = int3x2(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            int3x2 r2 = int3x2(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            TestUtils.AreEqual(a2--, r2);
+
+            int3x2 a3 = int3x2(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            int3x2 r3 = int3x2(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_and_wide_wide()
+        {
+            int3x2 a0 = int3x2(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558);
+            int3x2 b0 = int3x2(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877);
+            int3x2 r0 = int3x2(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x2 a1 = int3x2(1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            int3x2 b1 = int3x2(1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            int3x2 r1 = int3x2(1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x2 a2 = int3x2(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            int3x2 b2 = int3x2(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            int3x2 r2 = int3x2(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x2 a3 = int3x2(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int3x2 b3 = int3x2(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int3x2 r3 = int3x2(168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_and_wide_scalar()
+        {
+            int3x2 a0 = int3x2(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004);
+            int b0 = (93423598);
+            int3x2 r0 = int3x2(1114348, 85033216, 26281518, 8488942, 25232710, 67176356);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x2 a1 = int3x2(1941875181, 1365509729, 428270198, 607982857, 650270920, 1249238550);
+            int b1 = (1236735839);
+            int3x2 r1 = int3x2(1102446925, 1092879937, 159777366, 3478793, 8523848, 1211438614);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x2 a2 = int3x2(814629680, 143502472, 861733033, 1408932942, 957693145, 1567715668);
+            int b2 = (1862276471);
+            int3x2 r2 = int3x2(536871216, 134218752, 587202593, 1124078662, 687871057, 1291850068);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x2 a3 = int3x2(1102952410, 1599352836, 208656708, 1272226025, 462670926, 1817145060);
+            int b3 = (322053683);
+            int3x2 r3 = int3x2(19932690, 319823872, 2228224, 51388449, 319947778, 140832);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int3x2 b0 = int3x2(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958);
+            int3x2 r0 = int3x2(547170, 18752, 1074284806, 1140867104, 3672064, 3168358);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1159378889);
+            int3x2 b1 = int3x2(2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957);
+            int3x2 r1 = int3x2(1091605257, 1074836865, 9161, 1074299840, 83924360, 1092133121);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1248975349);
+            int3x2 b2 = int3x2(236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522);
+            int3x2 r2 = int3x2(168903041, 167844145, 1075925380, 1241581744, 140613985, 1074872496);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (2042776519);
+            int3x2 b3 = int3x2(56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404);
+            int3x2 r3 = int3x2(21118982, 1770146496, 1769996867, 1371555910, 1229064577, 1212170948);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_or_wide_wide()
+        {
+            int3x2 a0 = int3x2(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514);
+            int3x2 b0 = int3x2(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212);
+            int3x2 r0 = int3x2(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x2 a1 = int3x2(948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            int3x2 b1 = int3x2(2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            int3x2 r1 = int3x2(2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x2 a2 = int3x2(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            int3x2 b2 = int3x2(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            int3x2 r2 = int3x2(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x2 a3 = int3x2(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int3x2 b3 = int3x2(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int3x2 r3 = int3x2(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_or_wide_scalar()
+        {
+            int3x2 a0 = int3x2(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449);
+            int b0 = (1666102508);
+            int3x2 r0 = int3x2(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x2 a1 = int3x2(1048929715, 860336789, 1637162093, 1227888278, 774029856, 879300408);
+            int b1 = (1814263250);
+            int3x2 r1 = int3x2(2124903923, 2137520087, 1840741887, 1832089558, 1847850994, 2087419898);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x2 a2 = int3x2(1179087439, 1977614655, 46921989, 1980838747, 284225881, 64304104);
+            int b2 = (797240690);
+            int3x2 r2 = int3x2(1875378047, 2145709439, 802159991, 2140536699, 1073020283, 802553850);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x2 a3 = int3x2(313591807, 1890090886, 521303722, 2021379070, 2055963359, 1511253082);
+            int b3 = (1393862490);
+            int3x2 r3 = int3x2(1404413951, 1941766110, 1595340794, 2071982078, 2074060767, 1528293210);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int3x2 b0 = int3x2(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481);
+            int3x2 r0 = int3x2(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (1283571271);
+            int3x2 b1 = int3x2(2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741);
+            int3x2 r1 = int3x2(2109210439, 2128723919, 1558052575, 1608908663, 1838415447, 2141322991);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (627815046);
+            int3x2 b2 = int3x2(418822515, 83214352, 424663473, 447949225, 527022375, 1947148461);
+            int3x2 r2 = int3x2(1040169975, 637530774, 1030749111, 1073462191, 1064024999, 1970254511);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (305251437);
+            int3x2 b3 = int3x2(1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808);
+            int3x2 r3 = int3x2(1526199917, 2054417661, 1593566973, 1589235437, 1391839215, 335281389);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_xor_wide_wide()
+        {
+            int3x2 a0 = int3x2(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585);
+            int3x2 b0 = int3x2(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205);
+            int3x2 r0 = int3x2(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x2 a1 = int3x2(220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            int3x2 b1 = int3x2(535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            int3x2 r1 = int3x2(314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x2 a2 = int3x2(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            int3x2 b2 = int3x2(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            int3x2 r2 = int3x2(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x2 a3 = int3x2(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int3x2 b3 = int3x2(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int3x2 r3 = int3x2(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_xor_wide_scalar()
+        {
+            int3x2 a0 = int3x2(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690);
+            int b0 = (493665894);
+            int3x2 r0 = int3x2(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x2 a1 = int3x2(535061373, 1305234431, 353786540, 1308626970, 1267729267, 125659640);
+            int b1 = (289301586);
+            int3x2 r1 = int3x2(249169711, 1559375789, 69746430, 1597928520, 1521379105, 373493162);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x2 a2 = int3x2(1315625690, 116862046, 375757978, 491079274, 191750702, 187129429);
+            int b2 = (1730088797);
+            int3x2 r2 = int3x2(695588231, 1642603267, 1903858631, 2052737335, 1819471219, 1815630088);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x2 a3 = int3x2(967051293, 653124416, 788984, 1479174924, 1680011736, 447453839);
+            int b3 = (549951551);
+            int3x2 r3 = int3x2(425955362, 103447423, 550212039, 2028860211, 1155885543, 980157104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int3x2 b0 = int3x2(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275);
+            int3x2 r0 = int3x2(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1416249064);
+            int3x2 b1 = int3x2(1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003);
+            int3x2 r1 = int3x2(442541185, 1037166305, 227827390, 327742460, 280796832, 544217587);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1774252400);
+            int3x2 b2 = int3x2(1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053);
+            int3x2 r2 = int3x2(440379266, 698081028, 2022864761, 1000608691, 1580745115, 667852101);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (221134131);
+            int3x2 b3 = int3x2(885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520);
+            int3x2 r3 = int3x2(971170309, 693458543, 113181510, 1584258954, 790500762, 1630705027);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_left_shift()
+        {
+            int3x2 a0 = int3x2(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717);
+            int b0 = (1321149625);
+            int3x2 r0 = int3x2(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int3x2 a1 = int3x2(870301196, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302);
+            int b1 = (2058433484);
+            int3x2 r1 = int3x2(-69156864, 306012160, -1482059776, 20340736, -1775935488, -1561206784);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int3x2 a2 = int3x2(1079614371, 1664454606, 2045594989, 2077023268, 592678686, 297755411);
+            int b2 = (35667343);
+            int3x2 r2 = int3x2(-841908224, -941162496, -1497989120, 1846673408, -946929664, -1316388864);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int3x2 a3 = int3x2(1722762487, 37265945, 997793693, 1521705181, 263886278, 221147365);
+            int b3 = (1161625759);
+            int3x2 r3 = int3x2(-2147483648, -2147483648, -2147483648, -2147483648, 0, -2147483648);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_right_shift()
+        {
+            int3x2 a0 = int3x2(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656);
+            int b0 = (1266801540);
+            int3x2 r0 = int3x2(34260456, 72583643, 101101614, 116295740, 44622419, 12284541);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int3x2 a1 = int3x2(770466193, 572763124, 506619530, 426807581, 2031319045, 701927980);
+            int b1 = (1265099998);
+            int3x2 r1 = int3x2(0, 0, 0, 0, 1, 0);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int3x2 a2 = int3x2(917785020, 185593382, 1102123711, 334005460, 1624751550, 280138733);
+            int b2 = (569504877);
+            int3x2 r2 = int3x2(112034, 22655, 134536, 40772, 198333, 34196);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int3x2 a3 = int3x2(1598620011, 736389149, 1279158873, 408822762, 763607760, 348013684);
+            int b3 = (1840564178);
+            int3x2 r3 = int3x2(6098, 2809, 4879, 1559, 2912, 1327);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x2_operator_bitwise_not()
+        {
+            int3x2 a0 = int3x2(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339);
+            int3x2 r0 = int3x2(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340);
+            TestUtils.AreEqual(~a0, r0);
+
+            int3x2 a1 = int3x2(1935567517, 472965491, 771711426, 627580960, 2061524024, 753208488);
+            int3x2 r1 = int3x2(-1935567518, -472965492, -771711427, -627580961, -2061524025, -753208489);
+            TestUtils.AreEqual(~a1, r1);
+
+            int3x2 a2 = int3x2(2097179283, 664744603, 1289372466, 1635981125, 1951018596, 1545651937);
+            int3x2 r2 = int3x2(-2097179284, -664744604, -1289372467, -1635981126, -1951018597, -1545651938);
+            TestUtils.AreEqual(~a2, r2);
+
+            int3x2 a3 = int3x2(717936457, 1342785385, 869629475, 2045854321, 1282546942, 1562433528);
+            int3x2 r3 = int3x2(-717936458, -1342785386, -869629476, -2045854322, -1282546943, -1562433529);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..d34b6dfa93e42bb7e4330937fc11154d80b2bf2c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a70be02e3e9e4764494cdb824f94da34
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..b42ba490b9ec50c403cf433326449146cec54ba2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs
@@ -0,0 +1,1244 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt3x3
+    {
+        [TestCompiler]
+        public static void int3x3_zero()
+        {
+            TestUtils.AreEqual(int3x3.zero.c0.x, 0);
+            TestUtils.AreEqual(int3x3.zero.c0.y, 0);
+            TestUtils.AreEqual(int3x3.zero.c0.z, 0);
+            TestUtils.AreEqual(int3x3.zero.c1.x, 0);
+            TestUtils.AreEqual(int3x3.zero.c1.y, 0);
+            TestUtils.AreEqual(int3x3.zero.c1.z, 0);
+            TestUtils.AreEqual(int3x3.zero.c2.x, 0);
+            TestUtils.AreEqual(int3x3.zero.c2.y, 0);
+            TestUtils.AreEqual(int3x3.zero.c2.z, 0);
+        }
+
+        [TestCompiler]
+        public static void int3x3_identity()
+        {
+            TestUtils.AreEqual(int3x3.identity.c0.x, 1);
+            TestUtils.AreEqual(int3x3.identity.c0.y, 0);
+            TestUtils.AreEqual(int3x3.identity.c0.z, 0);
+            TestUtils.AreEqual(int3x3.identity.c1.x, 0);
+            TestUtils.AreEqual(int3x3.identity.c1.y, 1);
+            TestUtils.AreEqual(int3x3.identity.c1.z, 0);
+            TestUtils.AreEqual(int3x3.identity.c2.x, 0);
+            TestUtils.AreEqual(int3x3.identity.c2.y, 0);
+            TestUtils.AreEqual(int3x3.identity.c2.z, 1);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_equal_wide_wide()
+        {
+            int3x3 a0 = int3x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268);
+            int3x3 b0 = int3x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x3 a1 = int3x3(1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            int3x3 b1 = int3x3(2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x3 a2 = int3x3(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509, 1025529486, 2095601864, 193500113);
+            int3x3 b2 = int3x3(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580, 708665810, 1902328998, 1808456602);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x3 a3 = int3x3(1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            int3x3 b3 = int3x3(563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_equal_wide_scalar()
+        {
+            int3x3 a0 = int3x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538);
+            int b0 = (746972502);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x3 a1 = int3x3(795585660, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077, 442746747, 1772925698);
+            int b1 = (936027116);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x3 a2 = int3x3(1884034177, 425476075, 1370577708, 597010220, 1249636005, 211986678, 1305479811, 255635293, 1150443719);
+            int b2 = (451512860);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x3 a3 = int3x3(177122433, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291, 872759249);
+            int b3 = (511346787);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int3x3 b0 = int3x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1009011238);
+            int3x3 b1 = int3x3(312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (534746610);
+            int3x3 b2 = int3x3(559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403, 1839429063, 223575614);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (79701214);
+            int3x3 b3 = int3x3(1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415, 1576985758);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_not_equal_wide_wide()
+        {
+            int3x3 a0 = int3x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135);
+            int3x3 b0 = int3x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x3 a1 = int3x3(1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            int3x3 b1 = int3x3(1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x3 a2 = int3x3(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890, 922313145, 2006448607, 1574579050);
+            int3x3 b2 = int3x3(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634, 1944210269, 92849031, 164029425);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x3 a3 = int3x3(1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            int3x3 b3 = int3x3(628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_not_equal_wide_scalar()
+        {
+            int3x3 a0 = int3x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247);
+            int b0 = (248693828);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x3 a1 = int3x3(727205263, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883, 1622176923, 768370497);
+            int b1 = (1640688041);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x3 a2 = int3x3(1072798259, 1497830076, 1582645163, 1876273820, 90244766, 30493685, 904014575, 384643370, 11554610);
+            int b2 = (1808712713);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x3 a3 = int3x3(2016093187, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113, 765258490);
+            int b3 = (1515760622);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int3x3 b0 = int3x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (1512967900);
+            int3x3 b1 = int3x3(1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (1826089250);
+            int3x3 b2 = int3x3(1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024, 1936481966, 1366859342);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1775285431);
+            int3x3 b3 = int3x3(604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666, 358894860);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_wide_wide()
+        {
+            int3x3 a0 = int3x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233);
+            int3x3 b0 = int3x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337);
+            bool3x3 r0 = bool3x3(false, true, false, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x3 a1 = int3x3(789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            int3x3 b1 = int3x3(1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool3x3 r1 = bool3x3(true, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x3 a2 = int3x3(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162, 1638101724, 2044698552, 1543260981);
+            int3x3 b2 = int3x3(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133, 271967348, 1601249324, 1373999400);
+            bool3x3 r2 = bool3x3(true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x3 a3 = int3x3(471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            int3x3 b3 = int3x3(1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool3x3 r3 = bool3x3(true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_wide_scalar()
+        {
+            int3x3 a0 = int3x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491);
+            int b0 = (1491216667);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x3 a1 = int3x3(469591900, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709, 1286331950, 380753337);
+            int b1 = (1247103789);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x3 a2 = int3x3(971148054, 1056649851, 1579735991, 689044913, 1960894027, 371987110, 867559111, 1703747625, 1698536333);
+            int b2 = (1827886929);
+            bool3x3 r2 = bool3x3(true, true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x3 a3 = int3x3(41716206, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606, 1891059504);
+            int b3 = (243673862);
+            bool3x3 r3 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int3x3 b0 = int3x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251);
+            bool3x3 r0 = bool3x3(false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1102440676);
+            int3x3 b1 = int3x3(112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (358911716);
+            int3x3 b2 = int3x3(874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911, 1276652605, 593690439);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (771851138);
+            int3x3 b3 = int3x3(590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916, 168788814);
+            bool3x3 r3 = bool3x3(false, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_wide_wide()
+        {
+            int3x3 a0 = int3x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537);
+            int3x3 b0 = int3x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808);
+            bool3x3 r0 = bool3x3(true, true, false, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x3 a1 = int3x3(1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            int3x3 b1 = int3x3(976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x3 a2 = int3x3(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622, 1295065160, 715285504, 1130323487);
+            int3x3 b2 = int3x3(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265, 335209251, 1094341422, 1465325455);
+            bool3x3 r2 = bool3x3(false, false, false, true, true, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x3 a3 = int3x3(677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            int3x3 b3 = int3x3(390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool3x3 r3 = bool3x3(true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_wide_scalar()
+        {
+            int3x3 a0 = int3x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448);
+            int b0 = (438688675);
+            bool3x3 r0 = bool3x3(true, false, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x3 a1 = int3x3(304028799, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211, 2063134811, 1577403353);
+            int b1 = (893125636);
+            bool3x3 r1 = bool3x3(false, false, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x3 a2 = int3x3(64009107, 1143565920, 3715845, 689362811, 263973424, 1045140419, 1058332184, 524569092, 1183316983);
+            int b2 = (1462961460);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x3 a3 = int3x3(1107974092, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732, 1284938191);
+            int b3 = (212839726);
+            bool3x3 r3 = bool3x3(true, true, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int3x3 b0 = int3x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (741776730);
+            int3x3 b1 = int3x3(732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1858177345);
+            int3x3 b2 = int3x3(299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296, 292652611, 1002628348);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (927789921);
+            int3x3 b3 = int3x3(108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261, 267985383);
+            bool3x3 r3 = bool3x3(true, true, false, false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_equal_wide_wide()
+        {
+            int3x3 a0 = int3x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003);
+            int3x3 b0 = int3x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766);
+            bool3x3 r0 = bool3x3(false, true, false, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x3 a1 = int3x3(1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            int3x3 b1 = int3x3(1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x3 a2 = int3x3(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884, 912169992, 1992682021, 1619593455);
+            int3x3 b2 = int3x3(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017, 620752145, 1213693681, 1281818305);
+            bool3x3 r2 = bool3x3(true, false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x3 a3 = int3x3(1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            int3x3 b3 = int3x3(1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_equal_wide_scalar()
+        {
+            int3x3 a0 = int3x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706);
+            int b0 = (1688048545);
+            bool3x3 r0 = bool3x3(false, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x3 a1 = int3x3(1745758438, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948, 2017733017, 804204255);
+            int b1 = (532949158);
+            bool3x3 r1 = bool3x3(false, true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x3 a2 = int3x3(981729559, 910922522, 2079225209, 26179915, 238796519, 1917813750, 1258115260, 20607406, 1337879822);
+            int b2 = (2032949254);
+            bool3x3 r2 = bool3x3(true, true, false, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x3 a3 = int3x3(959460446, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244, 426908235);
+            int b3 = (1599429457);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int3x3 b0 = int3x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (11953554);
+            int3x3 b1 = int3x3(1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (957887737);
+            int3x3 b2 = int3x3(117849810, 1348693584, 105489302, 259034238, 530713566, 601413850, 830430286, 145552297, 1697295044);
+            bool3x3 r2 = bool3x3(false, true, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (1150680564);
+            int3x3 b3 = int3x3(2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260, 733876180);
+            bool3x3 r3 = bool3x3(true, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_equal_wide_wide()
+        {
+            int3x3 a0 = int3x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730);
+            int3x3 b0 = int3x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580);
+            bool3x3 r0 = bool3x3(false, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x3 a1 = int3x3(1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            int3x3 b1 = int3x3(1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x3 a2 = int3x3(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474, 605043041, 1707339660, 2038122892);
+            int3x3 b2 = int3x3(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253, 2025187918, 750755999, 869709740);
+            bool3x3 r2 = bool3x3(false, true, false, true, false, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x3 a3 = int3x3(345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            int3x3 b3 = int3x3(1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_equal_wide_scalar()
+        {
+            int3x3 a0 = int3x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196);
+            int b0 = (1470533736);
+            bool3x3 r0 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x3 a1 = int3x3(1604309397, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021, 196833647, 1596738181);
+            int b1 = (829548642);
+            bool3x3 r1 = bool3x3(true, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x3 a2 = int3x3(1905036391, 1584946560, 370941146, 440219668, 1607345862, 1449142607, 1223010129, 379014762, 1719435169);
+            int b2 = (1771391775);
+            bool3x3 r2 = bool3x3(true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x3 a3 = int3x3(258833609, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895, 192092521);
+            int b3 = (1389585003);
+            bool3x3 r3 = bool3x3(false, false, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int3x3 b0 = int3x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (1947039008);
+            int3x3 b1 = int3x3(1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577, 173706579, 625318949);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (519443238);
+            int3x3 b2 = int3x3(1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308, 479913036, 984991199);
+            bool3x3 r2 = bool3x3(false, false, false, true, false, false, true, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (172993285);
+            int3x3 b3 = int3x3(2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513, 474197678);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_add_wide_wide()
+        {
+            int3x3 a0 = int3x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704);
+            int3x3 b0 = int3x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231);
+            int3x3 r0 = int3x3(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135, -2009504361);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x3 a1 = int3x3(192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            int3x3 b1 = int3x3(908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            int3x3 r1 = int3x3(1101613923, -799189804, 1384643660, -147610603, 749502583, 623052937, -1181627673, -2116725070, -1148541136);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x3 a2 = int3x3(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366, 941872903, 906908654, 1940071697);
+            int3x3 b2 = int3x3(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905, 2106992817, 1994483489, 539473);
+            int3x3 r2 = int3x3(1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271, -1246101576, -1393575153, 1940611170);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x3 a3 = int3x3(862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            int3x3 b3 = int3x3(236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            int3x3 r3 = int3x3(1099044556, -1932199380, 1285092016, -1653104091, -537584005, 604086579, -2144211299, -668553705, -1620851127);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_add_wide_scalar()
+        {
+            int3x3 a0 = int3x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861);
+            int b0 = (2124409227);
+            int3x3 r0 = int3x3(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768, -167536208);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x3 a1 = int3x3(1635971971, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654, 756559204, 1818718931);
+            int b1 = (1160398286);
+            int3x3 r1 = int3x3(-1498597039, 1245844488, -2066416044, -1895181910, -1636892122, -1407091525, -2039130356, 1916957490, -1315850079);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x3 a2 = int3x3(658923552, 1585755398, 692843300, 1068593469, 1704776233, 577782260, 736972565, 711894571, 564257439);
+            int b2 = (1610518921);
+            int3x3 r2 = int3x3(-2025524823, -1098692977, -1991605075, -1615854906, -979672142, -2106666115, -1947475810, -1972553804, -2120190936);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x3 a3 = int3x3(2051736283, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190, 2092767444);
+            int b3 = (1572837697);
+            int3x3 r3 = int3x3(-670393316, -1094123054, -866429336, -2065380817, 1845612213, -804996400, -1893806626, -605319409, -629362155);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int3x3 b0 = int3x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825);
+            int3x3 r0 = int3x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146, 1387123903);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (1557774949);
+            int3x3 b1 = int3x3(779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874);
+            int3x3 r1 = int3x3(-1957417407, -1625651045, -1954145902, -1607028403, 1846054533, -1339508486, -1100608858, -2063929008, -1267891473);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (14855965);
+            int3x3 b2 = int3x3(1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835, 1992405574, 1213924458);
+            int3x3 r2 = int3x3(1131492964, 1503719265, 1615846851, 205507266, 1322315733, 934941804, 2097085800, 2007261539, 1228780423);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (505841452);
+            int3x3 b3 = int3x3(981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886, 1459523189);
+            int3x3 r3 = int3x3(1487262614, 1994179151, 1619668092, -1982979336, -1947334622, 712452303, 1032813405, 1742201338, 1965364641);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_sub_wide_wide()
+        {
+            int3x3 a0 = int3x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185);
+            int3x3 b0 = int3x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303);
+            int3x3 r0 = int3x3(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747, 1234495882);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x3 a1 = int3x3(579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            int3x3 b1 = int3x3(1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            int3x3 r1 = int3x3(-838948052, -732179165, -881462314, -50205903, -930193352, 120810088, 929308315, -624402009, -165899077);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x3 a2 = int3x3(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454, 425848588, 2026967474, 1128492011);
+            int3x3 b2 = int3x3(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855, 609588723, 1054324682, 1678086165);
+            int3x3 r2 = int3x3(-728396869, -162295434, 676719274, 647669761, 957134686, -776749401, -183740135, 972642792, -549594154);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x3 a3 = int3x3(61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            int3x3 b3 = int3x3(1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            int3x3 r3 = int3x3(-1468159992, -730634354, 1218011798, 1846728662, -555907518, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_sub_wide_scalar()
+        {
+            int3x3 a0 = int3x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200);
+            int b0 = (462232403);
+            int3x3 r0 = int3x3(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412, -181058203);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x3 a1 = int3x3(87530840, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635, 815920639, 1829033117);
+            int b1 = (1913724431);
+            int3x3 r1 = int3x3(-1826193591, 127868905, -1356484441, -794672983, -323347699, -1094634242, -1097341796, -1097803792, -84691314);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x3 a2 = int3x3(1792801932, 1418937976, 1277257189, 2092779398, 642236742, 1605250794, 819644478, 1468003019, 128303186);
+            int b2 = (1113440549);
+            int3x3 r2 = int3x3(679361383, 305497427, 163816640, 979338849, -471203807, 491810245, -293796071, 354562470, -985137363);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x3 a3 = int3x3(553494257, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204, 1835969317);
+            int b3 = (1017126971);
+            int3x3 r3 = int3x3(-463632714, 982617811, 1000145787, 800864793, 263858529, -340152116, 620905642, -67365767, 818842346);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int3x3 b0 = int3x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421);
+            int3x3 r0 = int3x3(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128, -97766016);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (264712893);
+            int3x3 b1 = int3x3(1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254);
+            int3x3 r1 = int3x3(-967143174, -1553399855, -1163723216, -994032567, -812667503, -1066009826, -253398936, -702415636, -79953361);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (1082267918);
+            int3x3 b2 = int3x3(907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777, 730060552, 1444397827);
+            int3x3 r2 = int3x3(174401222, -734617205, 621927350, 120113420, 525154457, -618948791, -897830859, 352207366, -362129909);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (853570556);
+            int3x3 b3 = int3x3(138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026, 902880656);
+            int3x3 r3 = int3x3(714734124, -159619872, 135481026, 346813166, -362877485, -82742191, -1143715899, -1116411470, -49310100);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mul_wide_wide()
+        {
+            int3x3 a0 = int3x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445);
+            int3x3 b0 = int3x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331);
+            int3x3 r0 = int3x3(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068, -1654168033);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x3 a1 = int3x3(1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            int3x3 b1 = int3x3(1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            int3x3 r1 = int3x3(2093463192, -1207506618, -1133560830, 990589280, -938173952, -1341723466, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x3 a2 = int3x3(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234, 899438811, 1765718681, 409003054);
+            int3x3 b2 = int3x3(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952, 675813713, 999254223, 1326064110);
+            int3x3 r2 = int3x3(1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720, 1891467339, 335415735, 1128927428);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x3 a3 = int3x3(2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            int3x3 b3 = int3x3(788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            int3x3 r3 = int3x3(-1656253776, -1433851638, 479369680, -366628060, -250163942, 48406862, -1997863296, -275121228, -1483457191);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mul_wide_scalar()
+        {
+            int3x3 a0 = int3x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632);
+            int b0 = (1476837906);
+            int3x3 r0 = int3x3(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518, 1736252960);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x3 a1 = int3x3(573770299, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467, 1186856590, 890343818);
+            int b1 = (1958912969);
+            int3x3 r1 = int3x3(-699623085, 583613531, -1685426426, 377032876, -1840882865, -459299359, 506042323, -1008908418, -1391844518);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x3 a2 = int3x3(800117742, 1338014500, 1688964615, 1439447294, 387721300, 1192501703, 1613845584, 76318055, 124378112);
+            int b2 = (606927173);
+            int3x3 r2 = int3x3(-1112302298, -254331724, 1687557859, 1193437814, 1547735716, -2021938781, -1509062256, 1364534211, -964408320);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x3 a3 = int3x3(970518733, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648, 227492421);
+            int b3 = (1370700538);
+            int3x3 r3 = int3x3(-524248526, 45251204, -1510152212, 28492454, 1649233534, -109154522, -1626217556, 1373293008, -567715486);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int3x3 b0 = int3x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483);
+            int3x3 r0 = int3x3(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328, 1623617844);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1178393968);
+            int3x3 b1 = int3x3(1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535);
+            int3x3 r1 = int3x3(1196573760, 592673296, 209320208, -352466736, 1007302672, -904186880, -1000629392, -2046820816, 1026909584);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1821413700);
+            int3x3 b2 = int3x3(677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236, 657101857, 1275563580);
+            int3x3 r2 = int3x3(118306580, 1091472052, 1879587908, -2118417516, -186623972, 1015975816, 1406756912, -1010431548, -883833872);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (1031291523);
+            int3x3 b3 = int3x3(1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263, 2022856151);
+            int3x3 r3 = int3x3(-2115383127, -1518963053, 358436435, -952500834, 469974843, -1901010273, -1775305962, 1424675509, -456434939);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_div_wide_wide()
+        {
+            int3x3 a0 = int3x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351);
+            int3x3 b0 = int3x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057);
+            int3x3 r0 = int3x3(1, 0, 0, 8, 0, 0, 2, 7, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x3 a1 = int3x3(1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            int3x3 b1 = int3x3(254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            int3x3 r1 = int3x3(5, 0, 0, 0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x3 a2 = int3x3(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343, 1735128704, 816492592, 2012272185);
+            int3x3 b2 = int3x3(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844, 616122946, 2035322800, 1324534444);
+            int3x3 r2 = int3x3(0, 1, 1, 1, 1, 0, 2, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x3 a3 = int3x3(632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            int3x3 b3 = int3x3(1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            int3x3 r3 = int3x3(0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_div_wide_scalar()
+        {
+            int3x3 a0 = int3x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568);
+            int b0 = (947861580);
+            int3x3 r0 = int3x3(0, 1, 0, 1, 2, 1, 1, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x3 a1 = int3x3(495895326, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372, 1447236569, 107215658);
+            int b1 = (1515313790);
+            int3x3 r1 = int3x3(0, 1, 1, 1, 0, 0, 1, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x3 a2 = int3x3(19616726, 707389627, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864, 1200843642, 206442634);
+            int b2 = (896899915);
+            int3x3 r2 = int3x3(0, 0, 1, 1, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x3 a3 = int3x3(1508567412, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918, 1515555001);
+            int b3 = (1825701056);
+            int3x3 r3 = int3x3(0, 0, 0, 0, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int3x3 b0 = int3x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373);
+            int3x3 r0 = int3x3(6, 0, 0, 0, 2, 0, 0, 1, 14);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (1476877645);
+            int3x3 b1 = int3x3(653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729);
+            int3x3 r1 = int3x3(2, 32, 2, 3, 1, 1, 0, 0, 5);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (48974453);
+            int3x3 b2 = int3x3(1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083, 131970646, 1320586926);
+            int3x3 r2 = int3x3(0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (366944102);
+            int3x3 b3 = int3x3(1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534, 126616016);
+            int3x3 r3 = int3x3(0, 1, 0, 0, 0, 8, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mod_wide_wide()
+        {
+            int3x3 a0 = int3x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078);
+            int3x3 b0 = int3x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442);
+            int3x3 r0 = int3x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x3 a1 = int3x3(1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            int3x3 b1 = int3x3(647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            int3x3 r1 = int3x3(164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x3 a2 = int3x3(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189, 1402964707, 2138294579, 1641714420);
+            int3x3 b2 = int3x3(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748, 798137669, 79717779, 1233582258);
+            int3x3 r2 = int3x3(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189, 604827038, 65632325, 408132162);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x3 a3 = int3x3(1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            int3x3 b3 = int3x3(1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            int3x3 r3 = int3x3(514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mod_wide_scalar()
+        {
+            int3x3 a0 = int3x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769);
+            int b0 = (883951171);
+            int3x3 r0 = int3x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x3 a1 = int3x3(405208598, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717, 165478511, 647846716);
+            int b1 = (1982762194);
+            int3x3 r1 = int3x3(405208598, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717, 165478511, 647846716);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x3 a2 = int3x3(915707999, 928191283, 1084934806, 488509689, 2087820912, 377501313, 1778384846, 1216011754, 812183417);
+            int b2 = (1602830401);
+            int3x3 r2 = int3x3(915707999, 928191283, 1084934806, 488509689, 484990511, 377501313, 175554445, 1216011754, 812183417);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x3 a3 = int3x3(1153802502, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372, 586777590);
+            int b3 = (1642671870);
+            int3x3 r3 = int3x3(1153802502, 282038872, 665297470, 1568090825, 408311072, 435886407, 453990946, 88993502, 586777590);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int3x3 b0 = int3x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573);
+            int3x3 r0 = int3x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1495295166);
+            int3x3 b1 = int3x3(873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842);
+            int3x3 r1 = int3x3(621971563, 433932700, 197192523, 1495295166, 494553075, 33923035, 1495295166, 698110479, 673406324);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (1083192997);
+            int3x3 b2 = int3x3(840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061, 730088119, 1444946139);
+            int3x3 r2 = int3x3(243078011, 1083192997, 468033033, 1083192997, 1875643, 1083192997, 95724631, 353104878, 1083192997);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1305792037);
+            int3x3 b3 = int3x3(1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894, 1342085447);
+            int3x3 r3 = int3x3(194963026, 433068456, 137860321, 1305792037, 282934571, 1305792037, 1305792037, 63018673, 1305792037);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_plus()
+        {
+            int3x3 a0 = int3x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897);
+            int3x3 r0 = int3x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a0, r0);
+
+            int3x3 a1 = int3x3(1287765427, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954, 1723005749, 409076474);
+            int3x3 r1 = int3x3(1287765427, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a1, r1);
+
+            int3x3 a2 = int3x3(591286416, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612);
+            int3x3 r2 = int3x3(591286416, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612);
+            TestUtils.AreEqual(+a2, r2);
+
+            int3x3 a3 = int3x3(500666137, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485, 1012749225);
+            int3x3 r3 = int3x3(500666137, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485, 1012749225);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_neg()
+        {
+            int3x3 a0 = int3x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238);
+            int3x3 r0 = int3x3(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349, -1115028238);
+            TestUtils.AreEqual(-a0, r0);
+
+            int3x3 a1 = int3x3(1636274969, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094, 1687250035, 2057919693);
+            int3x3 r1 = int3x3(-1636274969, -1542206286, -213087293, -243937487, -341522275, -841085242, -574159094, -1687250035, -2057919693);
+            TestUtils.AreEqual(-a1, r1);
+
+            int3x3 a2 = int3x3(1175014732, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454, 431666091, 1387601718);
+            int3x3 r2 = int3x3(-1175014732, -1212465326, -1190569920, -2047955772, -2120729864, -1440774928, -1485596454, -431666091, -1387601718);
+            TestUtils.AreEqual(-a2, r2);
+
+            int3x3 a3 = int3x3(1745651998, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868, 650922971);
+            int3x3 r3 = int3x3(-1745651998, -1119959806, -739132284, -1954173314, -1709857098, -1836511050, -1662806453, -506144868, -650922971);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_prefix_inc()
+        {
+            int3x3 a0 = int3x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639);
+            int3x3 r0 = int3x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a0, r0);
+
+            int3x3 a1 = int3x3(432884105, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683, 993189311, 752093909);
+            int3x3 r1 = int3x3(432884106, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a1, r1);
+
+            int3x3 a2 = int3x3(1622410417, 241906003, 1705625817, 609525897, 172599489, 504806865, 519296647, 281942776, 1541894135);
+            int3x3 r2 = int3x3(1622410418, 241906004, 1705625818, 609525898, 172599490, 504806866, 519296648, 281942777, 1541894136);
+            TestUtils.AreEqual(++a2, r2);
+
+            int3x3 a3 = int3x3(924683935, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111, 1414867743);
+            int3x3 r3 = int3x3(924683936, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112, 1414867744);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_postfix_inc()
+        {
+            int3x3 a0 = int3x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607);
+            int3x3 r0 = int3x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a0++, r0);
+
+            int3x3 a1 = int3x3(708474528, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530, 506142468, 732199129);
+            int3x3 r1 = int3x3(708474528, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a1++, r1);
+
+            int3x3 a2 = int3x3(2026873940, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901);
+            int3x3 r2 = int3x3(2026873940, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901);
+            TestUtils.AreEqual(a2++, r2);
+
+            int3x3 a3 = int3x3(101238629, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730, 1209169651);
+            int3x3 r3 = int3x3(101238629, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730, 1209169651);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_prefix_dec()
+        {
+            int3x3 a0 = int3x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580);
+            int3x3 r0 = int3x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a0, r0);
+
+            int3x3 a1 = int3x3(596759698, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956, 356565557, 18299409);
+            int3x3 r1 = int3x3(596759697, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a1, r1);
+
+            int3x3 a2 = int3x3(906734601, 1383897383, 1040798388, 1469596990, 1719228297, 220897829, 1454322707, 678025545, 14227726);
+            int3x3 r2 = int3x3(906734600, 1383897382, 1040798387, 1469596989, 1719228296, 220897828, 1454322706, 678025544, 14227725);
+            TestUtils.AreEqual(--a2, r2);
+
+            int3x3 a3 = int3x3(293093918, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380, 2083512379);
+            int3x3 r3 = int3x3(293093917, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379, 2083512378);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_postfix_dec()
+        {
+            int3x3 a0 = int3x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285);
+            int3x3 r0 = int3x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a0--, r0);
+
+            int3x3 a1 = int3x3(2017728859, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045, 2095777993, 670715645);
+            int3x3 r1 = int3x3(2017728859, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a1--, r1);
+
+            int3x3 a2 = int3x3(324944916, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377);
+            int3x3 r2 = int3x3(324944916, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377);
+            TestUtils.AreEqual(a2--, r2);
+
+            int3x3 a3 = int3x3(181847458, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130, 2016700604);
+            int3x3 r3 = int3x3(181847458, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130, 2016700604);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_and_wide_wide()
+        {
+            int3x3 a0 = int3x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114);
+            int3x3 b0 = int3x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139);
+            int3x3 r0 = int3x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x3 a1 = int3x3(1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            int3x3 b1 = int3x3(1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            int3x3 r1 = int3x3(1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x3 a2 = int3x3(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372, 181537307, 130347414, 1240828622);
+            int3x3 b2 = int3x3(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586, 1855189321, 185194029, 810374380);
+            int3x3 r2 = int3x3(168582, 1107890178, 67125280, 880844837, 541065292, 337646976, 177340425, 50384900, 4522188);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x3 a3 = int3x3(526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            int3x3 b3 = int3x3(133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            int3x3 r3 = int3x3(122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_and_wide_scalar()
+        {
+            int3x3 a0 = int3x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729);
+            int b0 = (93423598);
+            int3x3 r0 = int3x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x3 a1 = int3x3(428270198, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033, 1408932942, 957693145);
+            int b1 = (607982857);
+            int3x3 r1 = int3x3(262144, 603983880, 3478528, 537657600, 603985153, 853000, 538771465, 3675144, 538252297);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x3 a2 = int3x3(1567715668, 322053683, 1599352836, 208656708, 1272226025, 462670926, 1817145060, 1466722981, 1817277774);
+            int b2 = (1102952410);
+            int3x3 r2 = int3x3(1093742928, 19932690, 1091842048, 2986304, 1100259528, 26313802, 1074603712, 1093411456, 1074869578);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x3 a3 = int3x3(818900583, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061, 398141788);
+            int b3 = (772681077);
+            int3x3 r3 = int3x3(537799781, 537788480, 537527636, 604374309, 67241029, 705568773, 671747424, 167912453, 101329236);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int3x3 b0 = int3x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981);
+            int3x3 r0 = int3x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (270607307);
+            int3x3 b1 = int3x3(1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961);
+            int3x3 r1 = int3x3(270533570, 268501384, 8449, 2163137, 74123, 74507, 2163594, 66184, 270598977);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1436238522);
+            int3x3 b2 = int3x3(2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404, 2255485, 1814885263);
+            int3x3 r2 = int3x3(1367491202, 18563090, 1099055776, 1167655482, 1434992658, 1092288688, 1075397272, 148024, 1141392010);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1711986588);
+            int3x3 b3 = int3x3(1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007, 1808619374);
+            int3x3 r3 = int3x3(1140883976, 637536128, 1711801728, 101224968, 1610633224, 67682712, 1644860304, 67814532, 1644713740);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_or_wide_wide()
+        {
+            int3x3 a0 = int3x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222);
+            int3x3 b0 = int3x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169);
+            int3x3 r0 = int3x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x3 a1 = int3x3(396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            int3x3 b1 = int3x3(1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            int3x3 r1 = int3x3(1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x3 a2 = int3x3(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074, 543305337, 662107399, 1934997335);
+            int3x3 b2 = int3x3(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841, 108816721, 1694053551, 452638547);
+            int3x3 r2 = int3x3(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171, 645820281, 1744827823, 2080356183);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x3 a3 = int3x3(436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            int3x3 b3 = int3x3(1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            int3x3 r3 = int3x3(1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_or_wide_scalar()
+        {
+            int3x3 a0 = int3x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789);
+            int b0 = (1666102508);
+            int3x3 r0 = int3x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x3 a1 = int3x3(1637162093, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989, 1980838747, 284225881);
+            int b1 = (1227888278);
+            int3x3 r1 = int3x3(1773477631, 1865602742, 2105089982, 1333229279, 1874132982, 2112886719, 1274806167, 2133931999, 1508964319);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x3 a2 = int3x3(64304104, 1393862490, 1890090886, 521303722, 2021379070, 2055963359, 1511253082, 1775629833, 1142751163);
+            int b2 = (313591807);
+            int3x3 r2 = int3x3(334837759, 1404413951, 1924759551, 531855359, 2063323135, 2059110399, 1521739775, 2079717375, 1455292415);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x3 a3 = int3x3(1767274359, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200, 1353013374);
+            int b3 = (1421981808);
+            int3x3 r3 = int3x3(2111307639, 1576794359, 1559755519, 1961475324, 1455931127, 2096496501, 1607466226, 1440595320, 1424357502);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int3x3 b0 = int3x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710);
+            int3x3 r0 = int3x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (1348323481);
+            int3x3 b1 = int3x3(1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473, 447949225, 527022375);
+            int3x3 r1 = int3x3(1409150395, 2044710617, 2138963197, 1971321503, 1493170683, 1425918105, 1499453881, 1526720953, 1602091455);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (1947148461);
+            int3x3 b2 = int3x3(305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808, 2052547661, 582843231);
+            int3x3 r2 = int3x3(1983898861, 2127540973, 2088725757, 2129601277, 2124393197, 1961878511, 1976547565, 2120180973, 1992260607);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (656983670);
+            int3x3 b3 = int3x3(1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598, 1098359242);
+            int3x3 r3 = int3x3(2012151678, 1736044278, 931000318, 1060691710, 666879990, 1877598071, 800640759, 2139019006, 1736435710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_xor_wide_wide()
+        {
+            int3x3 a0 = int3x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340);
+            int3x3 b0 = int3x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711);
+            int3x3 r0 = int3x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x3 a1 = int3x3(643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            int3x3 b1 = int3x3(1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            int3x3 r1 = int3x3(1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x3 a2 = int3x3(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405, 1972524935, 91962333, 1960780785);
+            int3x3 b2 = int3x3(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483, 1340735463, 546583617, 1034420616);
+            int3x3 r2 = int3x3(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070, 981182560, 636424092, 1232544377);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x3 a3 = int3x3(1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            int3x3 b3 = int3x3(262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            int3x3 r3 = int3x3(1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_xor_wide_scalar()
+        {
+            int3x3 a0 = int3x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431);
+            int b0 = (493665894);
+            int3x3 r0 = int3x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x3 a1 = int3x3(353786540, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978, 491079274, 191750702);
+            int b1 = (1308626970);
+            int3x3 r1 = int3x3(1528187574, 93328233, 1232959970, 6998720, 689905479, 1224162372, 1483050112, 1397053040, 1164833332);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x3 a2 = int3x3(187129429, 549951551, 653124416, 788984, 1479174924, 1680011736, 447453839, 890841598, 293394300);
+            int b2 = (967051293);
+            int3x3 r2 = int3x3(847468104, 425955362, 524938077, 967311845, 1636721425, 1569126853, 588223122, 213721571, 685301601);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x3 a3 = int3x3(527727631, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239, 476052372);
+            int b3 = (529042816);
+            int3x3 r3 = int3x3(16576911, 1307134418, 1483505245, 548297055, 871053291, 475694844, 1940126849, 528638031, 64452116);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int3x3 b0 = int3x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217);
+            int3x3 r0 = int3x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1509843030);
+            int3x3 b1 = int3x3(1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099);
+            int3x3 r1 = int3x3(505195842, 489209886, 769935181, 809406758, 704722596, 430263842, 1219290719, 194675349, 1845940413);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1309568053);
+            int3x3 b2 = int3x3(221134131, 885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520, 86594349, 2006985393);
+            int3x3 r2 = int3x3(1126191366, 2059580163, 1786054505, 1168069184, 491622028, 1816020124, 571655301, 1260863256, 967722628);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1431761813);
+            int3x3 b3 = int3x3(905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615, 711527976);
+            int3x3 r3 = int3x3(1622008160, 266913576, 1579801450, 2144176381, 1125708626, 1502456780, 143731639, 2065991874, 2134900157);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_left_shift()
+        {
+            int3x3 a0 = int3x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230);
+            int b0 = (1321149625);
+            int3x3 r0 = int3x3(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464, -1409286144);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int3x3 a1 = int3x3(1531607705, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989, 2077023268, 592678686);
+            int b1 = (1360008038);
+            int3x3 r1 = int3x3(-761354688, 106468736, -1836333184, 375843008, -2012257344, -849087616, 2069060416, -214497024, -723269760);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int3x3 a2 = int3x3(297755411, 1161625759, 37265945, 997793693, 1521705181, 263886278, 221147365, 2084190583, 230910816);
+            int b2 = (1722762487);
+            int3x3 r2 = int3x3(-1988100096, 1333788672, 209715200, -830472192, 1853882368, -486539264, 1920991232, -1149239296, -1342177280);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int3x3 a3 = int3x3(71403448, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192, 740058147);
+            int b3 = (481375728);
+            int3x3 r3 = int3x3(-2017984512, -308281344, 1071316992, 705495040, 1989148672, 1981153280, -1414135808, 1022361600, 1680015360);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_right_shift()
+        {
+            int3x3 a0 = int3x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124);
+            int b0 = (1266801540);
+            int3x3 r0 = int3x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int3x3 a1 = int3x3(506619530, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711, 334005460, 1624751550);
+            int b1 = (426807581);
+            int3x3 r1 = int3x3(0, 3, 1, 1, 1, 0, 2, 0, 3);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int3x3 a2 = int3x3(280138733, 1840564178, 736389149, 1279158873, 408822762, 763607760, 348013684, 1568185874, 774126687);
+            int b2 = (1598620011);
+            int3x3 r2 = int3x3(136786, 898712, 359565, 624589, 199620, 372855, 169928, 765715, 377991);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int3x3 a3 = int3x3(1587054000, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381, 1234295294);
+            int b3 = (600069797);
+            int3x3 r3 = int3x3(49595437, 924264, 58780668, 11005463, 36390889, 13295044, 5829453, 34370605, 38571727);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x3_operator_bitwise_not()
+        {
+            int3x3 a0 = int3x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491);
+            int3x3 r0 = int3x3(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857, -472965492);
+            TestUtils.AreEqual(~a0, r0);
+
+            int3x3 a1 = int3x3(771711426, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466, 1635981125, 1951018596);
+            int3x3 r1 = int3x3(-771711427, -2061524025, -753208489, -2097179284, -1303022494, -664744604, -1289372467, -1635981126, -1951018597);
+            TestUtils.AreEqual(~a1, r1);
+
+            int3x3 a2 = int3x3(1545651937, 1284504687, 1342785385, 869629475, 2045854321, 1282546942, 1562433528, 1824824810, 1736570715);
+            int3x3 r2 = int3x3(-1545651938, -1284504688, -1342785386, -869629476, -2045854322, -1282546943, -1562433529, -1824824811, -1736570716);
+            TestUtils.AreEqual(~a2, r2);
+
+            int3x3 a3 = int3x3(508906058, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829, 1227946838);
+            int3x3 r3 = int3x3(-508906059, -1867418757, -388530275, -695179853, -1766938040, -897923627, -1816190465, -1362906830, -1227946839);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..c709a889e550d0e5ea26c8c4f60b97498a4b8d3a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e50b53d0c552004db62a39d61d06297
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..bb0955ffed1ece7c0ae37082d0bd484d63f98605
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs
@@ -0,0 +1,1233 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt3x4
+    {
+        [TestCompiler]
+        public static void int3x4_zero()
+        {
+            TestUtils.AreEqual(int3x4.zero.c0.x, 0);
+            TestUtils.AreEqual(int3x4.zero.c0.y, 0);
+            TestUtils.AreEqual(int3x4.zero.c0.z, 0);
+            TestUtils.AreEqual(int3x4.zero.c1.x, 0);
+            TestUtils.AreEqual(int3x4.zero.c1.y, 0);
+            TestUtils.AreEqual(int3x4.zero.c1.z, 0);
+            TestUtils.AreEqual(int3x4.zero.c2.x, 0);
+            TestUtils.AreEqual(int3x4.zero.c2.y, 0);
+            TestUtils.AreEqual(int3x4.zero.c2.z, 0);
+            TestUtils.AreEqual(int3x4.zero.c3.x, 0);
+            TestUtils.AreEqual(int3x4.zero.c3.y, 0);
+            TestUtils.AreEqual(int3x4.zero.c3.z, 0);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_equal_wide_wide()
+        {
+            int3x4 a0 = int3x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            int3x4 b0 = int3x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x4 a1 = int3x4(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int3x4 b1 = int3x4(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x4 a2 = int3x4(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            int3x4 b2 = int3x4(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x4 a3 = int3x4(346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            int3x4 b3 = int3x4(1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_equal_wide_scalar()
+        {
+            int3x4 a0 = int3x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411);
+            int b0 = (746972502);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int3x4 a1 = int3x4(672785749, 585324157, 404448210, 969511077, 442746747, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005);
+            int b1 = (1465584610);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int3x4 a2 = int3x4(211986678, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291);
+            int b2 = (1305479811);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int3x4 a3 = int3x4(872759249, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886, 20195989);
+            int b3 = (811880239);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int3x4 b0 = int3x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (737210539);
+            int3x4 b1 = int3x4(1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (597498209);
+            int3x4 b2 = int3x4(367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1576985758);
+            int3x4 b3 = int3x4(1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036, 2074160001);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_not_equal_wide_wide()
+        {
+            int3x4 a0 = int3x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            int3x4 b0 = int3x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x4 a1 = int3x4(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int3x4 b1 = int3x4(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x4 a2 = int3x4(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            int3x4 b2 = int3x4(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x4 a3 = int3x4(1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            int3x4 b3 = int3x4(1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_not_equal_wide_scalar()
+        {
+            int3x4 a0 = int3x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906);
+            int b0 = (248693828);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int3x4 a1 = int3x4(2126300423, 2035077187, 1171827730, 1412347883, 1622176923, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766);
+            int b1 = (791998981);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int3x4 a2 = int3x4(30493685, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113);
+            int b2 = (904014575);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int3x4 a3 = int3x4(765258490, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942, 780105497);
+            int b3 = (668154629);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int3x4 b0 = int3x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (50286949);
+            int3x4 b1 = int3x4(2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (510966350);
+            int3x4 b2 = int3x4(572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (358894860);
+            int3x4 b3 = int3x4(1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167, 1002934795);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_wide_wide()
+        {
+            int3x4 a0 = int3x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            int3x4 b0 = int3x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool3x4 r0 = bool3x4(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x4 a1 = int3x4(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int3x4 b1 = int3x4(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x4 a2 = int3x4(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            int3x4 b2 = int3x4(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool3x4 r2 = bool3x4(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x4 a3 = int3x4(1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            int3x4 b3 = int3x4(1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool3x4 r3 = bool3x4(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_wide_scalar()
+        {
+            int3x4 a0 = int3x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650);
+            int b0 = (1491216667);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int3x4 a1 = int3x4(930950514, 933855388, 908563901, 1127696709, 1286331950, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027);
+            int b1 = (1100560246);
+            bool3x4 r1 = bool3x4(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int3x4 a2 = int3x4(371987110, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606);
+            int b2 = (867559111);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int3x4 a3 = int3x4(1891059504, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493, 212954934);
+            int b3 = (1217893177);
+            bool3x4 r3 = bool3x4(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int3x4 b0 = int3x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311);
+            bool3x4 r0 = bool3x4(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1890019295);
+            int3x4 b1 = int3x4(2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659);
+            bool3x4 r1 = bool3x4(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (810406400);
+            int3x4 b2 = int3x4(1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916);
+            bool3x4 r2 = bool3x4(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (168788814);
+            int3x4 b3 = int3x4(670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033, 685700324);
+            bool3x4 r3 = bool3x4(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_wide_wide()
+        {
+            int3x4 a0 = int3x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            int3x4 b0 = int3x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool3x4 r0 = bool3x4(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x4 a1 = int3x4(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int3x4 b1 = int3x4(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x4 a2 = int3x4(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            int3x4 b2 = int3x4(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x4 a3 = int3x4(194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            int3x4 b3 = int3x4(1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_wide_scalar()
+        {
+            int3x4 a0 = int3x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515);
+            int b0 = (438688675);
+            bool3x4 r0 = bool3x4(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int3x4 a1 = int3x4(711945018, 577943770, 572743717, 1016617211, 2063134811, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424);
+            int b1 = (1035679270);
+            bool3x4 r1 = bool3x4(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int3x4 a2 = int3x4(1045140419, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732);
+            int b2 = (1058332184);
+            bool3x4 r2 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int3x4 a3 = int3x4(1284938191, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269, 1930086291);
+            int b3 = (1452639553);
+            bool3x4 r3 = bool3x4(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int3x4 b0 = int3x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1556466996);
+            int3x4 b1 = int3x4(858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711);
+            bool3x4 r1 = bool3x4(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1713088900);
+            int3x4 b2 = int3x4(315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (267985383);
+            int3x4 b3 = int3x4(126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217, 1480829811);
+            bool3x4 r3 = bool3x4(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_equal_wide_wide()
+        {
+            int3x4 a0 = int3x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            int3x4 b0 = int3x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool3x4 r0 = bool3x4(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x4 a1 = int3x4(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int3x4 b1 = int3x4(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x4 a2 = int3x4(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            int3x4 b2 = int3x4(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool3x4 r2 = bool3x4(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x4 a3 = int3x4(1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            int3x4 b3 = int3x4(1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_equal_wide_scalar()
+        {
+            int3x4 a0 = int3x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763);
+            int b0 = (1688048545);
+            bool3x4 r0 = bool3x4(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int3x4 a1 = int3x4(690091301, 2091514001, 1857173043, 1617221948, 2017733017, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519);
+            int b1 = (1806172431);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int3x4 a2 = int3x4(1917813750, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244);
+            int b2 = (1258115260);
+            bool3x4 r2 = bool3x4(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int3x4 a3 = int3x4(426908235, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266, 1483727269);
+            int b3 = (1818566980);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int3x4 b0 = int3x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1293698493);
+            int3x4 b1 = int3x4(48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (601413850);
+            int3x4 b2 = int3x4(830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260);
+            bool3x4 r2 = bool3x4(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (733876180);
+            int3x4 b3 = int3x4(1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410, 1987696011);
+            bool3x4 r3 = bool3x4(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_equal_wide_wide()
+        {
+            int3x4 a0 = int3x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            int3x4 b0 = int3x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool3x4 r0 = bool3x4(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x4 a1 = int3x4(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int3x4 b1 = int3x4(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x4 a2 = int3x4(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            int3x4 b2 = int3x4(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool3x4 r2 = bool3x4(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x4 a3 = int3x4(584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            int3x4 b3 = int3x4(2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_equal_wide_scalar()
+        {
+            int3x4 a0 = int3x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867);
+            int b0 = (1470533736);
+            bool3x4 r0 = bool3x4(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int3x4 a1 = int3x4(1419295004, 1819986195, 1460027917, 1646290021, 196833647, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862);
+            int b1 = (471843809);
+            bool3x4 r1 = bool3x4(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int3x4 a2 = int3x4(1449142607, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895);
+            int b2 = (1223010129);
+            bool3x4 r2 = bool3x4(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int3x4 a3 = int3x4(192092521, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700, 702382564);
+            int b3 = (909358617);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int3x4 b0 = int3x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (1214546726);
+            int3x4 b1 = int3x4(917376832, 303549425, 2111728811, 945321577, 173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189);
+            bool3x4 r1 = bool3x4(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (1336522452);
+            int3x4 b2 = int3x4(233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513);
+            bool3x4 r2 = bool3x4(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (474197678);
+            int3x4 b3 = int3x4(1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168, 1274079907);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_add_wide_wide()
+        {
+            int3x4 a0 = int3x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            int3x4 b0 = int3x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            int3x4 r0 = int3x4(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135, -2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x4 a1 = int3x4(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int3x4 b1 = int3x4(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int3x4 r1 = int3x4(-147610603, 749502583, 623052937, -1181627673, -2116725070, -1148541136, 1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x4 a2 = int3x4(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            int3x4 b2 = int3x4(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            int3x4 r2 = int3x4(-1246101576, -1393575153, 1940611170, 1099044556, -1932199380, 1285092016, -1653104091, -537584005, 604086579, -2144211299, -668553705, -1620851127);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x4 a3 = int3x4(728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            int3x4 b3 = int3x4(1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            int3x4 r3 = int3x4(-1833755501, 1450246522, -1850179797, 1669976746, -938217892, 1917402232, 1548618217, -1431586812, -823896228, 2013864506, 348877644, -2052539555);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_add_wide_scalar()
+        {
+            int3x4 a0 = int3x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202);
+            int b0 = (2124409227);
+            int3x4 r0 = int3x4(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768, -167536208, -534586098, -1010159783, -2085111867);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int3x4 a1 = int3x4(1068152966, 1497676888, 1727477485, 1095438654, 756559204, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233);
+            int b1 = (1239387100);
+            int3x4 r1 = int3x4(-1987427230, -1557903308, -1328102711, -1960141542, 1995946304, -1236861265, 1898310652, -1445061275, -1469824798, 1932230400, -1986986727, -1350803963);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int3x4 a2 = int3x4(577782260, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190);
+            int b2 = (736972565);
+            int3x4 r2 = int3x4(1314754825, 1448867136, 1301230004, -1506258448, -1985157034, -1929988186, -1702294468, 1393721347, 1009747081, -1640861532, 1565295538, -1441184541);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int3x4 a3 = int3x4(2092767444, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914, 1340503111);
+            int b3 = (973587865);
+            int3x4 r3 = int3x4(-1228611987, -2084448158, 1477852314, 1767880439, -1803320750, -1716743107, 1328461282, 1658835762, 1201369005, 1294770382, -2110803517, -1980876320);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int3x4 b0 = int3x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302);
+            int3x4 r0 = int3x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146, 1387123903, 1948867027, 1170867018, 1502633380);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (783046445);
+            int3x4 b1 = int3x4(1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768);
+            int3x4 r1 = int3x4(1913210389, 1071326029, -2114236990, -1875337362, 1456309784, -2042619977, 797902410, 1899683444, -2023057551, -1910929965, 973697746, 2090506213);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (920085839);
+            int3x4 b2 = int3x4(2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886);
+            int3x4 r2 = int3x4(-1292651622, -1382475883, 2134010297, 1425927291, 1901507001, -1886543758, 2033912479, -1568734949, -1533090235, 1126696690, 1447057792, -2138521571);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1459523189);
+            int3x4 b3 = int3x4(965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031, 1275565021);
+            int3x4 r3 = int3x4(-1869703476, 1542365988, -1537040906, -1029634335, -856579916, 1874526575, -929139959, -2112573910, -2091195311, -1158220548, 1762899220, -1559879086);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_sub_wide_wide()
+        {
+            int3x4 a0 = int3x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            int3x4 b0 = int3x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            int3x4 r0 = int3x4(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747, 1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x4 a1 = int3x4(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int3x4 b1 = int3x4(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int3x4 r1 = int3x4(-50205903, -930193352, 120810088, 929308315, -624402009, -165899077, -728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x4 a2 = int3x4(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            int3x4 b2 = int3x4(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            int3x4 r2 = int3x4(-183740135, 972642792, -549594154, -1468159992, -730634354, 1218011798, 1846728662, -555907518, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x4 a3 = int3x4(741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            int3x4 b3 = int3x4(1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            int3x4 r3 = int3x4(-345917539, 1650323877, 979082147, 182559134, -136395064, 1442113917, 8339009, 1379854326, -592461473, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_sub_wide_scalar()
+        {
+            int3x4 a0 = int3x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336);
+            int b0 = (462232403);
+            int3x4 r0 = int3x4(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412, -181058203, -374701563, 1451492028, 1579360933);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int3x4 a1 = int3x4(557239990, 1590376732, 819090189, 816382635, 815920639, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742);
+            int b1 = (1119051448);
+            int3x4 r1 = int3x4(-561811458, 471325284, -299961259, -302668813, -303130809, 709981669, 673750484, -5610899, 299886528, 158205741, 973727950, -476814706);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int3x4 a2 = int3x4(1605250794, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204);
+            int b2 = (819644478);
+            int3x4 r2 = int3x4(785606316, 648358541, -691341292, -266150221, 197482493, 1180100304, 1197628280, 998347286, 461341022, -142669623, 818388135, 130116726);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int3x4 a3 = int3x4(1835969317, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965, 941598524);
+            int b3 = (919015590);
+            int3x4 r3 = int3x4(916953727, 57931720, 385231016, 537764618, 635007122, -149211225, 1138816097, -160879011, -248582335, -315784179, 754253375, 22582934);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int3x4 b0 = int3x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748);
+            int3x4 r0 = int3x4(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128, -97766016, 1426821512, 459678338, -126578343);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (1428436109);
+            int3x4 b1 = int3x4(1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461);
+            int3x4 r1 = int3x4(169690649, 351055713, 97713390, 910324280, 461307580, 1083769855, 346168191, 520569413, -388449014, 968095541, 466281611, 871322648);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (1701216709);
+            int3x4 b2 = int3x4(1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026);
+            int3x4 r2 = int3x4(-278882068, 971156157, 256818882, 847646153, 1562380277, 688026281, 983127179, 1194459319, 484768668, 764903962, -296069746, -268765317);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (902880656);
+            int3x4 b3 = int3x4(1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072, 2066839749);
+            int3x4 r3 = int3x4(-258340041, -539584069, 279919891, 171911747, 288056815, -986898364, -15441696, 768950736, 689757548, -932569804, 381812584, -1163959093);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mul_wide_wide()
+        {
+            int3x4 a0 = int3x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            int3x4 b0 = int3x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            int3x4 r0 = int3x4(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068, -1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x4 a1 = int3x4(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int3x4 b1 = int3x4(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int3x4 r1 = int3x4(990589280, -938173952, -1341723466, 1156600361, 649177976, 678952165, 1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x4 a2 = int3x4(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            int3x4 b2 = int3x4(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            int3x4 r2 = int3x4(1891467339, 335415735, 1128927428, -1656253776, -1433851638, 479369680, -366628060, -250163942, 48406862, -1997863296, -275121228, -1483457191);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x4 a3 = int3x4(892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            int3x4 b3 = int3x4(142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            int3x4 r3 = int3x4(293009766, -617864326, 1179445736, -481780132, -1586128904, 1397450915, 487571412, -405680754, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mul_wide_scalar()
+        {
+            int3x4 a0 = int3x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747);
+            int b0 = (1476837906);
+            int3x4 r0 = int3x4(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518, 1736252960, -1699123674, -1534863838, -1853528010);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int3x4 a1 = int3x4(1818877398, 660611671, 1279757657, 391009467, 1186856590, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300);
+            int b1 = (1324050764);
+            int3x4 r1 = int3x4(1927061896, 645718228, -588613780, -844440956, -567685080, -1684615432, -1092253528, 133057916, -1582148944, -1029961452, -248833688, 100822256);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int3x4 a2 = int3x4(1192501703, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648);
+            int b2 = (1613845584);
+            int3x4 r2 = int3x4(-394864080, -1335460816, 692371456, 973833232, 1630959136, -1678368480, -191340960, 1516495024, 2027781488, 471196848, -2125435808, 1043640960);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int3x4 a3 = int3x4(227492421, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790, 396984449);
+            int b3 = (217698851);
+            int3x4 r3 = int3x4(269461871, 1120555251, 1293383984, 1838219542, -1271695412, 1677010101, 1900394426, 512258290, -238570208, -508870886, 1697920914, 1359963043);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int3x4 b0 = int3x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767);
+            int3x4 r0 = int3x4(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328, 1623617844, -1691554240, -830512240, -1283699420);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (243286231);
+            int3x4 b1 = int3x4(1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639);
+            int3x4 r1 = int3x4(-648389235, -1563629439, -401476800, -1314550601, 62369507, -76557479, -1413808100, -328103037, 2038656731, -2070911977, -1476360861, -1549578607);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1323243330);
+            int3x4 b2 = int3x4(1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263);
+            int3x4 r2 = int3x4(-94024808, 50866050, 1979584376, -2129139002, 2084048518, -630615902, 1987582754, -2107012204, -1274032366, 1909741994, 2131645412, 527678350);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (2022856151);
+            int3x4 b3 = int3x4(1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370, 890235481);
+            int3x4 r3 = int3x4(-1935205669, -686991577, -1926794436, -1053293830, -653994693, -1849661752, 1198448575, -1186284852, -1561308297, -1930349931, -910321442, 938433983);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_div_wide_wide()
+        {
+            int3x4 a0 = int3x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            int3x4 b0 = int3x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            int3x4 r0 = int3x4(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x4 a1 = int3x4(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int3x4 b1 = int3x4(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int3x4 r1 = int3x4(0, 2, 1, 2, 1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x4 a2 = int3x4(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            int3x4 b2 = int3x4(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            int3x4 r2 = int3x4(2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x4 a3 = int3x4(991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            int3x4 b3 = int3x4(554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            int3x4 r3 = int3x4(1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_div_wide_scalar()
+        {
+            int3x4 a0 = int3x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657);
+            int b0 = (947861580);
+            int3x4 r0 = int3x4(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int3x4 a1 = int3x4(2131487088, 1017891310, 542666029, 1646044372, 1447236569, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885);
+            int b1 = (2105094094);
+            int3x4 r1 = int3x4(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int3x4 a2 = int3x4(1919705924, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918);
+            int b2 = (1244966864);
+            int3x4 r2 = int3x4(1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int3x4 a3 = int3x4(1515555001, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647, 1222061694);
+            int b3 = (614923813);
+            int3x4 r3 = int3x4(2, 1, 3, 3, 3, 1, 3, 0, 0, 2, 3, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int3x4 b0 = int3x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703);
+            int3x4 r0 = int3x4(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (631027637);
+            int3x4 b1 = int3x4(396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043);
+            int3x4 r1 = int3x4(1, 0, 0, 0, 0, 2, 12, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1054404890);
+            int3x4 b2 = int3x4(351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534);
+            int3x4 r2 = int3x4(2, 7, 0, 2, 0, 4, 0, 0, 0, 23, 0, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (126616016);
+            int3x4 b3 = int3x4(1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719, 638134699);
+            int3x4 r3 = int3x4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mod_wide_wide()
+        {
+            int3x4 a0 = int3x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            int3x4 b0 = int3x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            int3x4 r0 = int3x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x4 a1 = int3x4(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int3x4 b1 = int3x4(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int3x4 r1 = int3x4(137194997, 593433700, 360454892, 8060301, 7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x4 a2 = int3x4(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            int3x4 b2 = int3x4(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            int3x4 r2 = int3x4(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x4 a3 = int3x4(1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            int3x4 b3 = int3x4(244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            int3x4 r3 = int3x4(166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mod_wide_scalar()
+        {
+            int3x4 a0 = int3x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935);
+            int b0 = (883951171);
+            int3x4 r0 = int3x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int3x4 a1 = int3x4(712321026, 1540068445, 1085897743, 1607489717, 165478511, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912);
+            int b1 = (172564850);
+            int3x4 r1 = int3x4(22061626, 159549645, 50508643, 54406067, 165478511, 130152166, 52883749, 49746751, 65367033, 49545706, 143379989, 17042712);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int3x4 a2 = int3x4(377501313, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372);
+            int b2 = (1778384846);
+            int3x4 r2 = int3x4(377501313, 1216011754, 812183417, 1153802502, 1642671870, 146325896, 665297470, 1568090825, 272598096, 435886407, 453990946, 1731665372);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int3x4 a3 = int3x4(586777590, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411, 1524342239);
+            int b3 = (1475597526);
+            int3x4 r3 = int3x4(586777590, 110051989, 1414579860, 416067455, 1262495021, 1400758118, 53934482, 430295164, 1386414018, 654749032, 666621411, 48744713);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int3x4 b0 = int3x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233);
+            int3x4 r0 = int3x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1298102643);
+            int3x4 b1 = int3x4(2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738);
+            int3x4 r1 = int3x4(1298102643, 297360552, 1298102643, 1298102643, 500917956, 476213801, 214909646, 457987657, 1298102643, 67782715, 1298102643, 1739061);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (2122220318);
+            int3x4 b2 = int3x4(164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894);
+            int3x4 r2 = int3x4(147283586, 662044080, 677274179, 816428281, 1011391307, 376773156, 120051662, 644373900, 76505386, 479992776, 159909553, 50931378);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1342085447);
+            int3x4 b3 = int3x4(448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751, 1648646354);
+            int3x4 r3 = int3x4(445362875, 3415371, 636619696, 588996674, 195741437, 241524871, 267605306, 1342085447, 1342085447, 1342085447, 243643696, 1342085447);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_plus()
+        {
+            int3x4 a0 = int3x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            int3x4 r0 = int3x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            TestUtils.AreEqual(+a0, r0);
+
+            int3x4 a1 = int3x4(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            int3x4 r1 = int3x4(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            TestUtils.AreEqual(+a1, r1);
+
+            int3x4 a2 = int3x4(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            int3x4 r2 = int3x4(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            TestUtils.AreEqual(+a2, r2);
+
+            int3x4 a3 = int3x4(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            int3x4 r3 = int3x4(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_neg()
+        {
+            int3x4 a0 = int3x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286);
+            int3x4 r0 = int3x4(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349, -1115028238, -1636274969, -694995093, -1542206286);
+            TestUtils.AreEqual(-a0, r0);
+
+            int3x4 a1 = int3x4(213087293, 341522275, 841085242, 574159094, 1687250035, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864);
+            int3x4 r1 = int3x4(-213087293, -341522275, -841085242, -574159094, -1687250035, -2057919693, -1175014732, -1259809073, -1212465326, -1190569920, -2047955772, -2120729864);
+            TestUtils.AreEqual(-a1, r1);
+
+            int3x4 a2 = int3x4(1440774928, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868);
+            int3x4 r2 = int3x4(-1440774928, -431666091, -1387601718, -1745651998, -319115626, -1119959806, -739132284, -1954173314, -1709857098, -1836511050, -1662806453, -506144868);
+            TestUtils.AreEqual(-a2, r2);
+
+            int3x4 a3 = int3x4(650922971, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551, 1768435578);
+            int3x4 r3 = int3x4(-650922971, -1273997249, -1474445187, -1853826947, -1695573773, -729452512, -345069360, -575867536, -594119038, -1201840609, -1342872551, -1768435578);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_prefix_inc()
+        {
+            int3x4 a0 = int3x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935);
+            int3x4 r0 = int3x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936);
+            TestUtils.AreEqual(++a0, r0);
+
+            int3x4 a1 = int3x4(1835605516, 388229350, 696475402, 1786514683, 993189311, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489);
+            int3x4 r1 = int3x4(1835605517, 388229351, 696475403, 1786514684, 993189312, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490);
+            TestUtils.AreEqual(++a1, r1);
+
+            int3x4 a2 = int3x4(504806865, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111);
+            int3x4 r2 = int3x4(504806866, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112);
+            TestUtils.AreEqual(++a2, r2);
+
+            int3x4 a3 = int3x4(1414867743, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802, 413165245);
+            int3x4 r3 = int3x4(1414867744, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803, 413165246);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_postfix_inc()
+        {
+            int3x4 a0 = int3x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            int3x4 r0 = int3x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            TestUtils.AreEqual(a0++, r0);
+
+            int3x4 a1 = int3x4(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            int3x4 r1 = int3x4(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            TestUtils.AreEqual(a1++, r1);
+
+            int3x4 a2 = int3x4(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            int3x4 r2 = int3x4(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            TestUtils.AreEqual(a2++, r2);
+
+            int3x4 a3 = int3x4(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            int3x4 r3 = int3x4(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_prefix_dec()
+        {
+            int3x4 a0 = int3x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358);
+            int3x4 r0 = int3x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357);
+            TestUtils.AreEqual(--a0, r0);
+
+            int3x4 a1 = int3x4(1914114460, 389120307, 1022184392, 1310293956, 356565557, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297);
+            int3x4 r1 = int3x4(1914114459, 389120306, 1022184391, 1310293955, 356565556, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296);
+            TestUtils.AreEqual(--a1, r1);
+
+            int3x4 a2 = int3x4(220897829, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380);
+            int3x4 r2 = int3x4(220897828, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379);
+            TestUtils.AreEqual(--a2, r2);
+
+            int3x4 a3 = int3x4(2083512379, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317, 767990877);
+            int3x4 r3 = int3x4(2083512378, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316, 767990876);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_postfix_dec()
+        {
+            int3x4 a0 = int3x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            int3x4 r0 = int3x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            TestUtils.AreEqual(a0--, r0);
+
+            int3x4 a1 = int3x4(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            int3x4 r1 = int3x4(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            TestUtils.AreEqual(a1--, r1);
+
+            int3x4 a2 = int3x4(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            int3x4 r2 = int3x4(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            TestUtils.AreEqual(a2--, r2);
+
+            int3x4 a3 = int3x4(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            int3x4 r3 = int3x4(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_and_wide_wide()
+        {
+            int3x4 a0 = int3x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            int3x4 b0 = int3x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            int3x4 r0 = int3x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x4 a1 = int3x4(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int3x4 b1 = int3x4(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int3x4 r1 = int3x4(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x4 a2 = int3x4(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            int3x4 b2 = int3x4(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            int3x4 r2 = int3x4(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x4 a3 = int3x4(1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            int3x4 b3 = int3x4(1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            int3x4 r3 = int3x4(706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_and_wide_scalar()
+        {
+            int3x4 a0 = int3x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920);
+            int b0 = (93423598);
+            int3x4 r0 = int3x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int3x4 a1 = int3x4(1249238550, 1862276471, 143502472, 861733033, 1408932942, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025);
+            int b1 = (814629680);
+            int3x4 r1 = int3x4(279056, 536871216, 9175040, 806092832, 277479424, 805568528, 268452112, 9175824, 268567088, 268697600, 934144, 8650784);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int3x4 a2 = int3x4(462670926, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061);
+            int b2 = (1817145060);
+            int3x4 r2 = int3x4(134433860, 1145858724, 1816224836, 542076516, 739126372, 1611530816, 537593028, 604439716, 1140983364, 672014980, 1745571424, 1208165380);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int3x4 a3 = int3x4(398141788, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172, 1826788967);
+            int b3 = (156911041);
+            int3x4 r3 = int3x4(18481472, 17843457, 5783937, 156763393, 22151233, 138937729, 152585345, 4867329, 21643264, 132544, 4719616, 138544193);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int3x4 b0 = int3x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596);
+            int3x4 r0 = int3x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1763483957);
+            int3x4 b1 = int3x4(1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366);
+            int3x4 r1 = int3x4(1209041205, 136061185, 151265585, 1074528516, 1744830512, 671121697, 1092091952, 1761607941, 18391060, 1761615904, 1763221553, 1091051540);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1233066417);
+            int3x4 b2 = int3x4(1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007);
+            int3x4 r2 = int3x4(1214058640, 2230321, 1210847617, 1074401680, 1211367456, 1116577, 1232603553, 3674113, 1078202400, 136118672, 1098518961, 4128897);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1808619374);
+            int3x4 b3 = int3x4(1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681, 1980296380);
+            int3x4 r3 = int3x4(1246058336, 1644778764, 12650346, 1640318254, 1216610624, 587220044, 1644695918, 33834028, 734795298, 671961678, 1241777216, 1644708908);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_or_wide_wide()
+        {
+            int3x4 a0 = int3x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            int3x4 b0 = int3x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            int3x4 r0 = int3x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x4 a1 = int3x4(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int3x4 b1 = int3x4(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int3x4 r1 = int3x4(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x4 a2 = int3x4(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            int3x4 b2 = int3x4(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            int3x4 r2 = int3x4(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x4 a3 = int3x4(470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            int3x4 b3 = int3x4(1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            int3x4 r3 = int3x4(1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_or_wide_scalar()
+        {
+            int3x4 a0 = int3x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856);
+            int b0 = (1666102508);
+            int3x4 r0 = int3x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int3x4 a1 = int3x4(879300408, 797240690, 1977614655, 46921989, 1980838747, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070);
+            int b1 = (1179087439);
+            int3x4 r1 = int3x4(1987018623, 1875378047, 2011657087, 1188035407, 1985442655, 1459090271, 1205302255, 1459058687, 1465382751, 1995407311, 1599567599, 2122316799);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int3x4 a2 = int3x4(2055963359, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200);
+            int b2 = (1511253082);
+            int3x4 r2 = int3x4(2057037535, 2077750875, 1579155451, 2069362559, 1590951034, 1534850271, 1593306847, 2050745566, 1519910623, 2117597023, 1604316378, 1600120154);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int3x4 a3 = int3x4(1353013374, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643, 142082352);
+            int b3 = (1349149982);
+            int3x4 r3 = int3x4(1357872510, 1895528286, 1374318015, 2012964638, 1550483390, 1602123263, 1483666815, 1920624063, 1458464191, 2012116286, 1424685023, 1484416318);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int3x4 b0 = int3x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649);
+            int3x4 r0 = int3x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (1059093741);
+            int3x4 b1 = int3x4(627815046, 418822515, 83214352, 424663473, 447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329);
+            int3x4 r1 = int3x4(1064042223, 1073151487, 1073085693, 1064304125, 1068727789, 1063910895, 2133818605, 1060240621, 2145910509, 2138209533, 2146074365, 2142830317);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (1088734150);
+            int3x4 b2 = int3x4(298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598);
+            int3x4 r2 = int3x4(1374682086, 2063067087, 1660812255, 1743570934, 1945042926, 1089859558, 1911943150, 2079645678, 1627375606, 1307434967, 1341444039, 1526649806);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (1098359242);
+            int3x4 b3 = int3x4(997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616, 1326199854);
+            int3x4 r3 = int3x4(2071978954, 1098885598, 2071455727, 1702356954, 1098381823, 1568651246, 2046802926, 1509946863, 2038414794, 1644161007, 1308081658, 1333769710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_xor_wide_wide()
+        {
+            int3x4 a0 = int3x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            int3x4 b0 = int3x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            int3x4 r0 = int3x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x4 a1 = int3x4(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int3x4 b1 = int3x4(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int3x4 r1 = int3x4(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x4 a2 = int3x4(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            int3x4 b2 = int3x4(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            int3x4 r2 = int3x4(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x4 a3 = int3x4(1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            int3x4 b3 = int3x4(1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            int3x4 r3 = int3x4(632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_xor_wide_scalar()
+        {
+            int3x4 a0 = int3x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267);
+            int b0 = (493665894);
+            int3x4 r0 = int3x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int3x4 a1 = int3x4(125659640, 1730088797, 116862046, 375757978, 491079274, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924);
+            int b1 = (1315625690);
+            int3x4 r1 = int3x4(1226289954, 695588231, 1218311812, 1477396032, 1395629232, 1158101236, 1162708111, 2010043079, 1856848613, 1753692570, 1315361570, 373338582);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int3x4 a2 = int3x4(1680011736, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239);
+            int b2 = (447453839);
+            int3x4 r2 = int3x4(2122935127, 800240497, 198659571, 98559616, 86185743, 1221222109, 1565485394, 630017616, 919085284, 427397619, 1988160398, 446789440);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int3x4 a3 = int3x4(476052372, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185, 1771744425);
+            int b3 = (92561487);
+            int3x4 r3 = int3x4(433822683, 2133436125, 133297725, 1274987888, 2020970994, 180462097, 52620731, 1114759625, 2024733453, 2005017615, 912470822, 1813957862);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int3x4 b0 = int3x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424);
+            int3x4 r0 = int3x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1947871003);
+            int3x4 b1 = int3x4(1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881);
+            int3x4 r1 = int3x4(500881003, 132477417, 876677487, 1699258642, 645842392, 1138923504, 974408494, 2033457704, 1087830061, 1348553799, 2139822446, 660194722);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (573581481);
+            int3x4 b2 = int3x4(1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615);
+            int3x4 r2 = int3x4(1311539225, 655981444, 1435501080, 2003229500, 399194716, 2022579220, 693043286, 145445825, 880683118, 787181808, 2146955403, 205673470);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (711527976);
+            int3x4 b3 = int3x4(710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645, 896851285);
+            int3x4 r3 = int3x4(3284335, 658000982, 154339351, 2085169939, 946304861, 44451568, 2115414221, 2137251591, 317021346, 552683235, 1575100285, 522048381);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_left_shift()
+        {
+            int3x4 a0 = int3x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534);
+            int b0 = (1321149625);
+            int3x4 r0 = int3x4(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464, -1409286144, 838860800, -872415232, -1409286144);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int3x4 a1 = int3x4(1447702302, 35667343, 1664454606, 2045594989, 2077023268, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181);
+            int b1 = (1079614371);
+            int3x4 r1 = int3x4(-1303283472, 285338744, 430734960, -815109272, -563683040, 446462192, -1912924008, 897198008, 703071480, 298127560, -607585048, -711260440);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int3x4 a2 = int3x4(263886278, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192);
+            int b2 = (221147365);
+            int3x4 r2 = int3x4(-145573696, -2025378080, -1200788480, -2010056960, -1775845888, -1021463552, 1296563040, -1738194528, 1884213760, -928070976, 160790208, 31956480);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int3x4 a3 = int3x4(740058147, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326, 1996060114);
+            int b3 = (946058001);
+            int3x4 r3 = int3x4(-934936576, -87949312, 1441398784, -1265369088, -5373952, -1576271872, -614334464, 1110573056, 1163132928, 173408256, 1445724160, -341573632);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_right_shift()
+        {
+            int3x4 a0 = int3x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045);
+            int b0 = (1266801540);
+            int3x4 r0 = int3x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int3x4 a1 = int3x4(701927980, 569504877, 185593382, 1102123711, 334005460, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762);
+            int b1 = (917785020);
+            int3x4 r1 = int3x4(2, 2, 0, 4, 1, 6, 1, 5, 6, 2, 4, 1);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int3x4 a2 = int3x4(763607760, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381);
+            int b2 = (348013684);
+            int3x4 r2 = int3x4(728, 1495, 738, 1513, 572, 28, 1793, 335, 1110, 405, 177, 1048);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int3x4 a3 = int3x4(1234295294, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981, 1435331003);
+            int b3 = (1028666766);
+            int3x4 r3 = int3x4(75335, 46488, 76590, 55139, 72040, 11168, 58514, 65650, 86028, 96236, 42779, 87605);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int3x4_operator_bitwise_not()
+        {
+            int3x4 a0 = int3x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024);
+            int3x4 r0 = int3x4(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857, -472965492, -771711427, -627580961, -2061524025);
+            TestUtils.AreEqual(~a0, r0);
+
+            int3x4 a1 = int3x4(753208488, 1303022493, 664744603, 1289372466, 1635981125, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321);
+            int3x4 r1 = int3x4(-753208489, -1303022494, -664744604, -1289372467, -1635981126, -1951018597, -1545651938, -717936458, -1284504688, -1342785386, -869629476, -2045854322);
+            TestUtils.AreEqual(~a1, r1);
+
+            int3x4 a2 = int3x4(1282546942, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829);
+            int3x4 r2 = int3x4(-1282546943, -1824824811, -1736570716, -508906059, -2060752881, -1867418757, -388530275, -695179853, -1766938040, -897923627, -1816190465, -1362906830);
+            TestUtils.AreEqual(~a2, r2);
+
+            int3x4 a3 = int3x4(1227946838, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010, 722020848);
+            int3x4 r3 = int3x4(-1227946839, -189609279, -956441809, -2123488811, -1593014252, -19223062, -1722107955, -1636875695, -1914097393, -1382545028, -1285277011, -722020849);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..281cb7b86f7e612d713ff8f76ee7122b62f31126
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt3x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f6cb6aa9b75ca25439dd64f10fe7d737
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..456e9b7e2a5593f7a3959d33bc8302048e3309e8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs
@@ -0,0 +1,1353 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt4
+    {
+        [TestCompiler]
+        public static void int4_zero()
+        {
+            TestUtils.AreEqual(int4.zero.x, 0);
+            TestUtils.AreEqual(int4.zero.y, 0);
+            TestUtils.AreEqual(int4.zero.z, 0);
+            TestUtils.AreEqual(int4.zero.w, 0);
+        }
+
+        [TestCompiler]
+        public static void int4_constructor()
+        {
+            int4 a = new int4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void int4_scalar_constructor()
+        {
+            int4 a = new int4(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+            TestUtils.AreEqual(a.z, 17);
+            TestUtils.AreEqual(a.w, 17);
+        }
+
+        [TestCompiler]
+        public static void int4_static_constructor()
+        {
+            int4 a = int4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void int4_static_scalar_constructor()
+        {
+            int4 a = int4(17);
+            TestUtils.AreEqual(a.x, 17);
+            TestUtils.AreEqual(a.y, 17);
+            TestUtils.AreEqual(a.z, 17);
+            TestUtils.AreEqual(a.w, 17);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_equal_wide_wide()
+        {
+            int4 a0 = int4(790229414, 970783976, 1428432738, 1578747135);
+            int4 b0 = int4(612337669, 1214209108, 2120643427, 295461214);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4 a1 = int4(1733797753, 2001507228, 1446876437, 1777406370);
+            int4 b1 = int4(1510890331, 1893316566, 921816149, 1834958575);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4 a2 = int4(1426387268, 1809275021, 1843770816, 1172185222);
+            int4 b2 = int4(1482011863, 2062852792, 226398742, 770290735);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4 a3 = int4(1469608940, 869874758, 458603090, 581282460);
+            int4 b3 = int4(36812057, 543224481, 1565350150, 1909926604);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_equal_wide_scalar()
+        {
+            int4 a0 = int4(1211464300, 1921862607, 508076684, 1249127920);
+            int b0 = (746972502);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4 a1 = int4(1394594555, 1733655277, 1884008277, 1682018538);
+            int b1 = (746862310);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4 a2 = int4(795585660, 927605411, 672785749, 1465584610);
+            int b2 = (936027116);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4 a3 = int4(585324157, 969511077, 442746747, 1772925698);
+            int b3 = (404448210);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int4 b0 = int4(233855098, 924242519, 1402948791, 601381975);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (2120518068);
+            int4 b1 = int4(629187703, 1971977031, 47183124, 1061805787);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (1009011238);
+            int4 b2 = int4(312511148, 1460673064, 737210539, 1737844479);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1892405453);
+            int4 b3 = int4(2133024000, 455818693, 2003197687, 1276241219);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_not_equal_wide_wide()
+        {
+            int4 a0 = int4(1660932106, 982847023, 97046264, 1739517447);
+            int4 b0 = int4(107139049, 75478496, 2055495054, 358586687);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4 a1 = int4(1253499180, 1830584069, 1841470429, 1397841646);
+            int4 b1 = int4(942338347, 111564990, 113811950, 948912488);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4 a2 = int4(1770890135, 1906548631, 169082967, 2099271786);
+            int4 b2 = int4(1080084121, 1400504872, 1032134499, 1061123400);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4 a3 = int4(1909317609, 46519139, 1433204003, 931492669);
+            int4 b3 = int4(221862069, 858950046, 989094643, 2023070999);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_not_equal_wide_scalar()
+        {
+            int4 a0 = int4(747758183, 1033001286, 1439973882, 2138928797);
+            int b0 = (248693828);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4 a1 = int4(1197845089, 950170763, 238704450, 2105962247);
+            int b1 = (1432672459);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4 a2 = int4(727205263, 276313906, 2126300423, 791998981);
+            int b2 = (1640688041);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4 a3 = int4(2035077187, 1412347883, 1622176923, 768370497);
+            int b3 = (1171827730);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int4 b0 = int4(2037494727, 1989050616, 48833929, 1897435904);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (514354517);
+            int4 b1 = int4(1783749164, 364694471, 754315072, 124108032);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (1512967900);
+            int4 b2 = int4(1178825850, 1854793298, 50286949, 2100802631);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1640811853);
+            int4 b3 = int4(82110247, 472172806, 266984506, 2003668365);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_wide_wide()
+        {
+            int4 a0 = int4(1182186063, 415538999, 1667335818, 1566618442);
+            int4 b0 = int4(524633529, 1032195686, 760723389, 1505751409);
+            bool4 r0 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4 a1 = int4(1166180837, 639095188, 1080836365, 771119973);
+            int4 b1 = int4(431962172, 1287906509, 1560084663, 1450178202);
+            bool4 r1 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4 a2 = int4(928263233, 789225474, 665243110, 1003542034);
+            int4 b2 = int4(2066166337, 1107069023, 1640077524, 2103263105);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4 a3 = int4(1032480172, 1961336172, 923379558, 21210619);
+            int4 b3 = int4(684229139, 1234033624, 1278743281, 1953079347);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_wide_scalar()
+        {
+            int4 a0 = int4(608447185, 818840405, 869219329, 2080125385);
+            int b0 = (1491216667);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4 a1 = int4(1214500548, 1667165786, 1615392341, 840091491);
+            int b1 = (1361741203);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4 a2 = int4(469591900, 315321650, 930950514, 1100560246);
+            int b2 = (1247103789);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4 a3 = int4(933855388, 1127696709, 1286331950, 380753337);
+            int b3 = (908563901);
+            bool4 r3 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int4 b0 = int4(282703327, 14370648, 1862117300, 1304793311);
+            bool4 r0 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (826073259);
+            int4 b1 = int4(988910157, 445132446, 1139670255, 111349251);
+            bool4 r1 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1102440676);
+            int4 b2 = int4(112183144, 1594415311, 1890019295, 2098715503);
+            bool4 r2 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (608933527);
+            int4 b3 = int4(183989010, 1596056507, 1027318999, 146281093);
+            bool4 r3 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_wide_wide()
+        {
+            int4 a0 = int4(592884447, 2133928932, 918957182, 1284069471);
+            int4 b0 = int4(138737040, 192863971, 1700841444, 1044631301);
+            bool4 r0 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4 a1 = int4(194584707, 739120780, 241654068, 1340158550);
+            int4 b1 = int4(1391589821, 730837695, 253553987, 2078872742);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4 a2 = int4(2099542537, 1182623667, 1399607274, 789301637);
+            int4 b2 = int4(910845808, 976047676, 202633078, 1223618940);
+            bool4 r2 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4 a3 = int4(180400925, 594688333, 1877031463, 1360073500);
+            int4 b3 = int4(641600530, 1830470354, 1570701388, 1104256103);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_wide_scalar()
+        {
+            int4 a0 = int4(1097138316, 211763648, 1883002501, 56406996);
+            int b0 = (438688675);
+            bool4 r0 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4 a1 = int4(43662641, 1437755186, 1219010035, 2125058448);
+            int b1 = (1923456111);
+            bool4 r1 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4 a2 = int4(304028799, 48044515, 711945018, 1035679270);
+            int b2 = (893125636);
+            bool4 r2 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4 a3 = int4(577943770, 1016617211, 2063134811, 1577403353);
+            int b3 = (572743717);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int4 b0 = int4(599356784, 185671342, 1932327391, 2025591013);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1257191721);
+            int4 b1 = int4(1312388500, 1443698859, 779217735, 691047512);
+            bool4 r1 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (741776730);
+            int4 b2 = int4(732565983, 668302204, 1556466996, 858599525);
+            bool4 r2 = bool4(true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (1896917159);
+            int4 b3 = int4(701542098, 1052151621, 1023307544, 1435392907);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_equal_wide_wide()
+        {
+            int4 a0 = int4(1577248162, 2043073061, 1688380407, 176431985);
+            int4 b0 = int4(903445031, 2108974565, 210822256, 1281704747);
+            bool4 r0 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4 a1 = int4(223299035, 1502802140, 1691709825, 386789394);
+            int4 b1 = int4(453681718, 66138830, 1229799377, 1620922595);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4 a2 = int4(117182003, 1665770435, 1958490731, 420032601);
+            int4 b2 = int4(1715833766, 1366430432, 13102000, 46919981);
+            bool4 r2 = bool4(true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4 a3 = int4(1251092689, 2011681765, 749743684, 183784440);
+            int4 b3 = int4(486470891, 1709514236, 2145785285, 854254454);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_equal_wide_scalar()
+        {
+            int4 a0 = int4(1722165358, 1219858357, 860410743, 411099660);
+            int b0 = (1688048545);
+            bool4 r0 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4 a1 = int4(348104022, 212084836, 58924407, 1459242706);
+            int b1 = (1963256951);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4 a2 = int4(1745758438, 262559763, 690091301, 1806172431);
+            int b2 = (532949158);
+            bool4 r2 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4 a3 = int4(2091514001, 1617221948, 2017733017, 804204255);
+            int b3 = (1857173043);
+            bool4 r3 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int4 b0 = int4(1181030049, 1787703989, 1729760948, 1816537388);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1359786460);
+            int4 b1 = int4(874999193, 1678863148, 1711365839, 762067160);
+            bool4 r1 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (11953554);
+            int4 b2 = int4(1131583906, 1175393186, 1293698493, 48893340);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (66196247);
+            int4 b3 = int4(1958607116, 1576473309, 861890786, 478252419);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_equal_wide_wide()
+        {
+            int4 a0 = int4(263000030, 744235661, 1893760267, 237248);
+            int4 b0 = int4(1395535146, 1178373944, 1237373760, 1364855321);
+            bool4 r0 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4 a1 = int4(1062370984, 1676977687, 816766880, 1089431546);
+            int4 b1 = int4(600811864, 362060472, 290870624, 1839067862);
+            bool4 r1 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4 a2 = int4(1394493730, 1176473380, 1193988637, 1703862455);
+            int4 b2 = int4(396958580, 1336888643, 1019684398, 1697684196);
+            bool4 r2 = bool4(true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4 a3 = int4(1806186947, 1253571980, 589397635, 1951842887);
+            int4 b3 = int4(1227300220, 2044269675, 1898323839, 874509380);
+            bool4 r3 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_equal_wide_scalar()
+        {
+            int4 a0 = int4(2112791350, 1043657935, 101764761, 1529909067);
+            int b0 = (1470533736);
+            bool4 r0 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4 a1 = int4(556026890, 1186600258, 815093894, 609211196);
+            int b1 = (281734132);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4 a2 = int4(1604309397, 244604867, 1419295004, 471843809);
+            int b2 = (829548642);
+            bool4 r2 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4 a3 = int4(1819986195, 1646290021, 196833647, 1596738181);
+            int b3 = (1460027917);
+            bool4 r3 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int4 b0 = int4(1503244746, 861711266, 817773856, 925984572);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (571221723);
+            int4 b1 = int4(683686810, 118252990, 1653952090, 1240253990);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (1947039008);
+            int4 b2 = int4(1869136019, 152012637, 1214546726, 917376832);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (303549425);
+            int4 b3 = int4(2111728811, 945321577, 173706579, 625318949);
+            bool4 r3 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_add_wide_wide()
+        {
+            int4 a0 = int4(2049228671, 1658660009, 491719392, 937013355);
+            int4 b0 = int4(2088751567, 645762023, 306868786, 4360271);
+            int4 r0 = int4(-156987058, -1990545264, 798588178, 941373626);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4 a1 = int4(81108663, 1063894558, 86954702, 843159721);
+            int4 b1 = int4(506047997, 2094559874, 1634712736, 1601474440);
+            int4 r1 = int4(587156660, -1136512864, 1721667438, -1850333135);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4 a2 = int4(698977704, 192867135, 1683407172, 137301303);
+            int4 b2 = int4(1586485231, 908746788, 1812370320, 1247342357);
+            int4 r2 = int4(-2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4 a3 = int4(2103582820, 526139155, 447937230, 2127411006);
+            int4 b3 = int4(2043773873, 223363428, 175115707, 985928617);
+            int4 r3 = int4(-147610603, 749502583, 623052937, -1181627673);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_add_wide_scalar()
+        {
+            int4 a0 = int4(2038218457, 134923711, 875689667, 1338884463);
+            int b0 = (2124409227);
+            int4 r0 = int4(-132339612, -2035634358, -1294868402, -831673606);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4 a1 = int4(997710928, 1067888129, 70433301, 2003021861);
+            int b1 = (340490871);
+            int4 r1 = int4(1338201799, 1408379000, 410924172, -1951454564);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4 a2 = int4(1635971971, 85446202, 1068152966, 1239387100);
+            int b2 = (1160398286);
+            int4 r2 = int4(-1498597039, 1245844488, -2066416044, -1895181910);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4 a3 = int4(1497676888, 1095438654, 756559204, 1818718931);
+            int b3 = (1727477485);
+            int4 r3 = int4(-1069812923, -1472051157, -1810930607, -748770880);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int4 b0 = int4(519908870, 851424292, 328314822, 135622204);
+            int4 r0 = int4(911000948, 1242516370, 719406900, 526714282);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (740923360);
+            int4 b1 = int4(655394201, 1451896269, 1781697072, 996031825);
+            int4 r1 = int4(1396317561, -2102147667, -1772346864, 1736955185);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1557774949);
+            int4 b2 = int4(779774940, 1111541302, 783046445, 1130163944);
+            int4 r2 = int4(-1957417407, -1625651045, -1954145902, -1607028403);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (288279584);
+            int4 b3 = int4(1397683861, 1636583489, 673263339, 1469300874);
+            int4 r3 = int4(1685963445, 1924863073, 961542923, 1757580458);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_sub_wide_wide()
+        {
+            int4 a0 = int4(1353441118, 797269833, 659988112, 56022121);
+            int4 b0 = int4(1332656812, 1827794007, 972557431, 2078233689);
+            int4 r0 = int4(20784306, -1030524174, -312569319, -2022211568);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4 a1 = int4(365847472, 2062899435, 1380988474, 799885138);
+            int4 b1 = int4(1508184327, 1372307701, 810327977, 936799885);
+            int4 r1 = int4(-1142336855, 690591734, 570660497, -136914747);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4 a2 = int4(1306058185, 579775276, 1239163824, 344591081);
+            int4 b2 = int4(71562303, 1418723328, 1971342989, 1226053395);
+            int4 r2 = int4(1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4 a3 = int4(86359575, 1049709943, 721529513, 1767221271);
+            int4 b3 = int4(136565478, 1979903295, 600719425, 837912956);
+            int4 r3 = int4(-50205903, -930193352, 120810088, 929308315);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_sub_wide_scalar()
+        {
+            int4 a0 = int4(1176369558, 1934521195, 309452150, 1417634074);
+            int b0 = (462232403);
+            int4 r0 = int4(714137155, 1472288792, -152780253, 955401671);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4 a1 = int4(108910717, 1502312334, 1451794815, 281174200);
+            int b1 = (1306356714);
+            int4 r1 = int4(-1197445997, 195955620, 145438101, -1025182514);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4 a2 = int4(87530840, 2041593336, 557239990, 1119051448);
+            int b2 = (1913724431);
+            int4 r2 = int4(-1826193591, 127868905, -1356484441, -794672983);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4 a3 = int4(1590376732, 816382635, 815920639, 1829033117);
+            int b3 = (819090189);
+            int4 r3 = int4(771286543, -2707554, -3169550, 1009942928);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int4 b0 = int4(2022393810, 1612688515, 496689713, 887037586);
+            int4 r0 = int4(-330859405, 78845890, 1194844692, 804496819);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (2097630964);
+            int4 b1 = int4(374934538, 939035482, 935242277, 1789300421);
+            int4 r1 = int4(1722696426, 1158595482, 1162388687, 308330543);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (264712893);
+            int4 b2 = int4(1231856067, 1818112748, 1428436109, 1258745460);
+            int4 r2 = int4(-967143174, -1553399855, -1163723216, -994032567);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1077380396);
+            int4 b3 = int4(1330722719, 518111829, 967128529, 344666254);
+            int4 r3 = int4(-253342323, 559268567, 110251867, 732714142);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mul_wide_wide()
+        {
+            int4 a0 = int4(245827027, 208934650, 1019478917, 568231809);
+            int4 b0 = int4(759663997, 350129201, 477450108, 1635735015);
+            int4 r0 = int4(-632811769, 1402281434, 332447596, -1932977561);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4 a1 = int4(877289039, 1585782440, 2111178729, 1186019069);
+            int4 b1 = int4(388710278, 757722665, 1509388321, 1841703980);
+            int4 r1 = int4(-1670918566, 1455036648, 2128344329, -594088068);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4 a2 = int4(571481445, 1570087048, 629447153, 619383734);
+            int4 b2 = int4(1826369331, 1524322467, 1605207974, 428419155);
+            int4 r2 = int4(-1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4 a3 = int4(2055121568, 700402816, 263414349, 187830569);
+            int4 b3 = int4(1460605791, 1968043860, 771161742, 2037340417);
+            int4 r3 = int4(990589280, -938173952, -1341723466, 1156600361);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mul_wide_scalar()
+        {
+            int4 a0 = int4(1762033447, 465343930, 1570757881, 1326409563);
+            int b0 = (1476837906);
+            int4 r0 = int4(-1313177922, 1326807828, -2138555518, -276153754);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4 a1 = int4(1824319147, 72749215, 154616909, 975743632);
+            int b1 = (1356578909);
+            int4 r1 = int4(-236385249, 130042307, 1244434425, -1981680048);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4 a2 = int4(573770299, 971327747, 1818877398, 1324050764);
+            int b2 = (1958912969);
+            int4 r2 = int4(-699623085, 583613531, -1685426426, 377032876);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4 a3 = int4(660611671, 391009467, 1186856590, 890343818);
+            int b3 = (1279757657);
+            int4 r3 = int4(-42542273, 1120105475, -22825634, 1972017914);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int4 b0 = int4(1764461774, 657072478, 1459784358, 1610646683);
+            int4 r0 = int4(-950398648, -102049016, 1260585960, 1158730452);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (1632058826);
+            int4 b1 = int4(868441654, 1408757883, 335917146, 2105124483);
+            int4 r1 = int4(-57330532, -1559359474, 712546564, -805332386);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1178393968);
+            int4 b2 = int4(1963904348, 1409533767, 243286231, 1336308795);
+            int4 r2 = int4(1196573760, 592673296, 209320208, -352466736);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (517963367);
+            int4 b3 = int4(1733623488, 459880225, 994616533, 1420531535);
+            int4 r3 = int4(-774570176, -1271501753, 652617651, -1789672759);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_div_wide_wide()
+        {
+            int4 a0 = int4(1590198532, 507812502, 126627032, 1058247011);
+            int4 b0 = int4(1434703236, 911965201, 390415521, 128746927);
+            int4 r0 = int4(1, 0, 0, 8);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4 a1 = int4(427387861, 290676154, 1829594484, 1127868739);
+            int4 b1 = int4(525835375, 816946613, 878264647, 146789678);
+            int4 r1 = int4(0, 0, 2, 7);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4 a2 = int4(499016351, 1341209632, 134906097, 785470242);
+            int4 b2 = int4(2089524057, 254213018, 1916850021, 1737806518);
+            int4 r2 = int4(0, 5, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4 a3 = int4(788249865, 1099825433, 1552968283, 1822367139);
+            int4 b3 = int4(1906634983, 437754923, 825037958, 902508708);
+            int4 r3 = int4(0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_div_wide_scalar()
+        {
+            int4 a0 = int4(560951562, 1218680769, 375341724, 1613542090);
+            int b0 = (947861580);
+            int4 r0 = int4(0, 1, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4 a1 = int4(1919409166, 1349573078, 524526253, 341995568);
+            int b1 = (1397425408);
+            int4 r1 = int4(1, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4 a2 = int4(495895326, 1676971657, 2131487088, 2105094094);
+            int b2 = (1515313790);
+            int4 r2 = int4(0, 1, 1, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4 a3 = int4(1017891310, 1646044372, 1447236569, 107215658);
+            int b3 = (542666029);
+            int4 r3 = int4(1, 3, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int4 b0 = int4(187325733, 1594107378, 2016183849, 1589343709);
+            int4 r0 = int4(6, 0, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (388768753);
+            int4 b1 = int4(1417077283, 1773486938, 1154044032, 81831373);
+            int4 r1 = int4(0, 0, 0, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1476877645);
+            int4 b2 = int4(653688843, 45756703, 631027637, 396671391);
+            int4 r2 = int4(2, 32, 2, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (784365696);
+            int4 b3 = int4(1250594097, 1818363859, 1653451772, 270557729);
+            int4 r3 = int4(0, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mod_wide_wide()
+        {
+            int4 a0 = int4(146150818, 1846543305, 1071447756, 308965362);
+            int4 b0 = int4(983050390, 771341152, 942375212, 367361754);
+            int4 r0 = int4(146150818, 303861001, 129072544, 308965362);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4 a1 = int4(659881575, 1002365460, 861198439, 1510617532);
+            int4 b1 = int4(749500619, 750718852, 2095151755, 88438806);
+            int4 r1 = int4(659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4 a2 = int4(778525078, 1458458044, 101987897, 1249565173);
+            int4 b2 = int4(769227442, 647214624, 1026513788, 1544950956);
+            int4 r2 = int4(9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4 a3 = int4(938026607, 1692541775, 1518877124, 1806965510);
+            int4 b3 = int4(160166322, 1099108075, 1158422232, 1798905209);
+            int4 r3 = int4(137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mod_wide_scalar()
+        {
+            int4 a0 = int4(164800505, 1062177828, 1898749675, 1701653318);
+            int b0 = (883951171);
+            int4 r0 = int4(164800505, 178226657, 130847333, 817702147);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4 a1 = int4(820393245, 128329633, 1464010899, 896587769);
+            int b1 = (19002208);
+            int4 r1 = int4(3298301, 14316385, 840883, 3483993);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4 a2 = int4(405208598, 959236935, 712321026, 172564850);
+            int b2 = (1982762194);
+            int4 r2 = int4(405208598, 959236935, 712321026, 172564850);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4 a3 = int4(1540068445, 1607489717, 165478511, 647846716);
+            int b3 = (1085897743);
+            int4 r3 = int4(454170702, 521591974, 165478511, 647846716);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int4 b0 = int4(740000543, 1556450291, 1104736385, 437976569);
+            int4 r0 = int4(242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1911837205);
+            int4 b1 = int4(1507212038, 1906405167, 247693265, 293460573);
+            int4 r1 = int4(404625167, 5432038, 177984350, 151073767);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (1495295166);
+            int4 b2 = int4(873323603, 530681233, 1298102643, 2057984657);
+            int4 r2 = int4(621971563, 433932700, 197192523, 1495295166);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1000742091);
+            int4 b3 = int4(1461372131, 1859742342, 797184687, 821888842);
+            int4 r3 = int4(1000742091, 1000742091, 203557404, 178853249);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_plus()
+        {
+            int4 a0 = int4(1643476803, 907898539, 379615839, 1140483021);
+            int4 r0 = int4(1643476803, 907898539, 379615839, 1140483021);
+            TestUtils.AreEqual(+a0, r0);
+
+            int4 a1 = int4(1735287433, 1472881565, 339091479, 401565897);
+            int4 r1 = int4(1735287433, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a1, r1);
+
+            int4 a2 = int4(1287765427, 174532915, 1864850812, 1566098441);
+            int4 r2 = int4(1287765427, 174532915, 1864850812, 1566098441);
+            TestUtils.AreEqual(+a2, r2);
+
+            int4 a3 = int4(1145639744, 2049663954, 1723005749, 409076474);
+            int4 r3 = int4(1145639744, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_neg()
+        {
+            int4 a0 = int4(1955022112, 662160019, 370300775, 2141283773);
+            int4 r0 = int4(-1955022112, -662160019, -370300775, -2141283773);
+            TestUtils.AreEqual(-a0, r0);
+
+            int4 a1 = int4(1004505619, 33894270, 505708349, 1115028238);
+            int4 r1 = int4(-1004505619, -33894270, -505708349, -1115028238);
+            TestUtils.AreEqual(-a1, r1);
+
+            int4 a2 = int4(1636274969, 1542206286, 213087293, 243937487);
+            int4 r2 = int4(-1636274969, -1542206286, -213087293, -243937487);
+            TestUtils.AreEqual(-a2, r2);
+
+            int4 a3 = int4(341522275, 574159094, 1687250035, 2057919693);
+            int4 r3 = int4(-341522275, -574159094, -1687250035, -2057919693);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_prefix_inc()
+        {
+            int4 a0 = int4(864455342, 2035793213, 1275443862, 971919915);
+            int4 r0 = int4(864455343, 2035793214, 1275443863, 971919916);
+            TestUtils.AreEqual(++a0, r0);
+
+            int4 a1 = int4(411610189, 395072276, 115573442, 913293639);
+            int4 r1 = int4(411610190, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a1, r1);
+
+            int4 a2 = int4(432884105, 1385544935, 1835605516, 831396561);
+            int4 r2 = int4(432884106, 1385544936, 1835605517, 831396562);
+            TestUtils.AreEqual(++a2, r2);
+
+            int4 a3 = int4(388229350, 1786514683, 993189311, 752093909);
+            int4 r3 = int4(388229351, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_postfix_inc()
+        {
+            int4 a0 = int4(1751003569, 2063707595, 1500486291, 969189211);
+            int4 r0 = int4(1751003569, 2063707595, 1500486291, 969189211);
+            TestUtils.AreEqual(a0++, r0);
+
+            int4 a1 = int4(1007848192, 1643023524, 1190630527, 1396179607);
+            int4 r1 = int4(1007848192, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a1++, r1);
+
+            int4 a2 = int4(708474528, 1524860667, 1408994706, 375284401);
+            int4 r2 = int4(708474528, 1524860667, 1408994706, 375284401);
+            TestUtils.AreEqual(a2++, r2);
+
+            int4 a3 = int4(1580130369, 717006530, 506142468, 732199129);
+            int4 r3 = int4(1580130369, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_prefix_dec()
+        {
+            int4 a0 = int4(200904609, 871077500, 968578728, 638967721);
+            int4 r0 = int4(200904608, 871077499, 968578727, 638967720);
+            TestUtils.AreEqual(--a0, r0);
+
+            int4 a1 = int4(1995396216, 1782514098, 1589827826, 1434377580);
+            int4 r1 = int4(1995396215, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a1, r1);
+
+            int4 a2 = int4(596759698, 1758478358, 1914114460, 71237375);
+            int4 r2 = int4(596759697, 1758478357, 1914114459, 71237374);
+            TestUtils.AreEqual(--a2, r2);
+
+            int4 a3 = int4(389120307, 1310293956, 356565557, 18299409);
+            int4 r3 = int4(389120306, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_postfix_dec()
+        {
+            int4 a0 = int4(283970262, 1109329936, 1073216143, 649439137);
+            int4 r0 = int4(283970262, 1109329936, 1073216143, 649439137);
+            TestUtils.AreEqual(a0--, r0);
+
+            int4 a1 = int4(1932646215, 484207852, 524156737, 691209285);
+            int4 r1 = int4(1932646215, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a1--, r1);
+
+            int4 a2 = int4(2017728859, 377162390, 526366486, 1504625034);
+            int4 r2 = int4(2017728859, 377162390, 526366486, 1504625034);
+            TestUtils.AreEqual(a2--, r2);
+
+            int4 a3 = int4(590919177, 1867810045, 2095777993, 670715645);
+            int4 r3 = int4(590919177, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_and_wide_wide()
+        {
+            int4 a0 = int4(779935043, 1097962163, 1939593304, 800599247);
+            int4 b0 = int4(307705143, 1710882162, 866836769, 532490608);
+            int4 r0 = int4(39064835, 1097961522, 864731136, 263727168);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4 a1 = int4(952140918, 782792558, 1608557706, 396446406);
+            int4 b1 = int4(679371720, 1794035877, 1439832202, 519529812);
+            int4 r1 = int4(675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4 a2 = int4(2039894114, 1286974642, 442394124, 1759739564);
+            int4 b2 = int4(23633139, 1209152681, 646737179, 1255867027);
+            int4 r2 = int4(16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4 a3 = int4(233435438, 665207770, 1942050241, 1022352952);
+            int4 b3 = int4(1900854122, 413173763, 1409138251, 2087190272);
+            int4 r3 = int4(21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_and_wide_scalar()
+        {
+            int4 a0 = int4(443615469, 490057985, 2042441263, 1524760558);
+            int b0 = (93423598);
+            int4 r0 = int4(1114348, 85033216, 26281518, 8488942);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4 a1 = int4(1405175110, 1941875181, 1236735839, 1365509729);
+            int b1 = (510212004);
+            int4 r1 = int4(306251012, 304619940, 136386308, 274728480);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4 a2 = int4(428270198, 650270920, 1249238550, 814629680);
+            int b2 = (607982857);
+            int4 r2 = int4(262144, 603983880, 3478528, 537657600);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4 a3 = int4(1862276471, 861733033, 1408932942, 957693145);
+            int b3 = (143502472);
+            int4 r3 = int4(134218752, 852104, 8948744, 134556808);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int4 b0 = int4(420346723, 562416448, 1393127318, 1560699552);
+            int4 r0 = int4(547170, 18752, 1074284806, 1140867104);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (851218057);
+            int4 b1 = int4(703880958, 1159378889, 2031211279, 1089518981);
+            int4 r1 = int4(548671112, 1607305, 806388233, 11570305);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (270607307);
+            int4 b2 = int4(1349288930, 520199596, 1763483957, 1248975349);
+            int4 r2 = int4(270533570, 268501384, 8449, 2163137);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (236938635);
+            int4 b3 = int4(185023291, 1085233038, 1845693112, 946052961);
+            int4 r3 = int4(168239371, 1000842, 235077768, 134415617);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_or_wide_wide()
+        {
+            int4 a0 = int4(1731159103, 659068416, 382702471, 1821032196);
+            int4 b0 = int4(1583847161, 692672727, 1161585489, 1756207130);
+            int4 r0 = int4(2138044159, 793370327, 1476391895, 1823457054);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4 a1 = int4(1565773438, 1004000514, 948501377, 600951835);
+            int4 b1 = int4(1321374429, 1287357212, 2075767170, 1273513430);
+            int4 r1 = int4(1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4 a2 = int4(669346222, 396691477, 2108560248, 2117522137);
+            int4 b2 = int4(1610830169, 1316929125, 511625048, 573925879);
+            int4 r2 = int4(1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4 a3 = int4(330307355, 818676817, 1774459567, 1117506257);
+            int4 b3 = int4(1502255628, 1841676448, 1682928938, 1115131952);
+            int4 r3 = int4(1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_or_wide_scalar()
+        {
+            int4 a0 = int4(961259683, 471103264, 1733389229, 1591585258);
+            int b0 = (1666102508);
+            int4 r0 = int4(2068823279, 2136930284, 1734344685, 2145369582);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4 a1 = int4(386953869, 1048929715, 1814263250, 860336789);
+            int b1 = (1148351449);
+            int4 r1 = int4(1467118557, 2130147323, 1819506651, 2004349917);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4 a2 = int4(1637162093, 774029856, 879300408, 1179087439);
+            int b2 = (1227888278);
+            int4 r2 = int4(1773477631, 1865602742, 2105089982, 1333229279);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4 a3 = int4(797240690, 46921989, 1980838747, 284225881);
+            int b3 = (1977614655);
+            int4 r3 = int4(2145709439, 2011953471, 2012296063, 1978724735);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int4 b0 = int4(1212928242, 1614462616, 936937728, 764766995);
+            int4 r0 = int4(1213978111, 1752940445, 2145094925, 1842867999);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (306352095);
+            int4 b1 = int4(574719481, 1283571271, 2109131012, 979469710);
+            int4 r1 = int4(843288575, 1589886943, 2146881503, 979603423);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (1348323481);
+            int4 b2 = int4(1407542578, 697517649, 1059093741, 627815046);
+            int4 r2 = int4(1409150395, 2044710617, 2138963197, 1971321503);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (418822515);
+            int4 b3 = int4(83214352, 424663473, 447949225, 527022375);
+            int4 r3 = int4(486013299, 436206067, 452442619, 536852855);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_xor_wide_wide()
+        {
+            int4 a0 = int4(1556324760, 207002929, 1843444873, 1632079131);
+            int4 b0 = int4(1054997548, 1523759632, 251164872, 110472397);
+            int4 r0 = int4(1646419380, 1451501345, 1662567489, 1741824470);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4 a1 = int4(1460334334, 1607815585, 220623650, 38668553);
+            int4 b1 = int4(384031112, 1109163205, 535118981, 179106262);
+            int4 r1 = int4(1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4 a2 = int4(47193340, 643663548, 1371932564, 94957188);
+            int4 b2 = int4(1523031711, 1713313372, 1294118730, 520360641);
+            int4 r2 = int4(1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4 a3 = int4(700973621, 370621508, 2087573076, 351476570);
+            int4 b3 = int4(1040688781, 1020757245, 1143954843, 1281933464);
+            int4 r3 = int4(399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_xor_wide_scalar()
+        {
+            int4 a0 = int4(2124666952, 177397845, 574879617, 1937385541);
+            int b0 = (493665894);
+            int4 r0 = int4(1674536494, 402546227, 1060063719, 1846973987);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4 a1 = int4(1136545648, 535061373, 289301586, 1305234431);
+            int b1 = (213863690);
+            int4 r1 = int4(1325466234, 324742775, 495003992, 1098057461);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4 a2 = int4(353786540, 1267729267, 125659640, 1315625690);
+            int b2 = (1308626970);
+            int4 r2 = int4(1528187574, 93328233, 1232959970, 6998720);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4 a3 = int4(1730088797, 375757978, 491079274, 191750702);
+            int b3 = (116862046);
+            int4 r3 = int4(1642603267, 278048964, 464677428, 228249200);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int4 b0 = int4(1077599928, 884741329, 212164516, 1585020328);
+            int4 r0 = int4(217506340, 2020616269, 1080648504, 313868596);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (152985454);
+            int4 b1 = int4(1775851275, 1416249064, 1309317737, 1773918217);
+            int4 r1 = int4(1623656549, 1567908230, 1192543495, 1621460839);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1509843030);
+            int4 b2 = int4(1206045972, 1154916424, 1947871003, 1774252400);
+            int4 r2 = int4(505195842, 489209886, 769935181, 809406758);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1946113778);
+            int4 b3 = int4(1079717492, 290620937, 1382343363, 939045099);
+            int4 r3 = int4(866416774, 1655558395, 563852337, 1141368345);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_left_shift()
+        {
+            int4 a0 = int4(197771193, 622182602, 1283988958, 1327917304);
+            int b0 = (1321149625);
+            int4 r0 = int4(1912602624, -1811939328, -1140850688, -268435456);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int4 a1 = int4(473415985, 870301196, 2058433484, 1200694230);
+            int b1 = (432425717);
+            int4 r1 = int4(639631360, -1048576000, 2038431744, 2059403264);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int4 a2 = int4(1531607705, 1008296534, 1447702302, 1079614371);
+            int b2 = (1360008038);
+            int4 r2 = int4(-761354688, 106468736, -1836333184, 375843008);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int4 a3 = int4(35667343, 2045594989, 2077023268, 592678686);
+            int b3 = (1664454606);
+            int4 r3 = int4(258195456, 1398489088, 923336704, -473464832);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_right_shift()
+        {
+            int4 a0 = int4(548167301, 1161338299, 1617625829, 1860731847);
+            int b0 = (1266801540);
+            int4 r0 = int4(34260456, 72583643, 101101614, 116295740);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int4 a1 = int4(713958715, 770466193, 1265099998, 572763124);
+            int b1 = (196552656);
+            int4 r1 = int4(10894, 11756, 19303, 8739);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int4 a2 = int4(506619530, 2031319045, 701927980, 917785020);
+            int b2 = (426807581);
+            int4 r2 = int4(0, 3, 1, 1);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int4 a3 = int4(569504877, 1102123711, 334005460, 1624751550);
+            int b3 = (185593382);
+            int4 r3 = int4(8898513, 17220682, 5218835, 25386742);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_operator_bitwise_not()
+        {
+            int4 a0 = int4(1403358969, 831360921, 2088190243, 976721016);
+            int4 r0 = int4(-1403358970, -831360922, -2088190244, -976721017);
+            TestUtils.AreEqual(~a0, r0);
+
+            int4 a1 = int4(878283189, 1935567517, 1420884856, 472965491);
+            int4 r1 = int4(-878283190, -1935567518, -1420884857, -472965492);
+            TestUtils.AreEqual(~a1, r1);
+
+            int4 a2 = int4(771711426, 2061524024, 753208488, 2097179283);
+            int4 r2 = int4(-771711427, -2061524025, -753208489, -2097179284);
+            TestUtils.AreEqual(~a2, r2);
+
+            int4 a3 = int4(1303022493, 1289372466, 1635981125, 1951018596);
+            int4 r3 = int4(-1303022494, -1289372467, -1635981126, -1951018597);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4_shuffle_result_1()
+        {
+            int4 a = int4(0, 1, 2, 3);
+            int4 b = int4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW), (3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ), (6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW), (7));
+        }
+
+        [TestCompiler]
+        public static void int4_shuffle_result_2()
+        {
+            int4 a = int4(0, 1, 2, 3);
+            int4 b = int4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), int2(5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX), int2(6, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), int2(1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftW), int2(7, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftZ), int2(7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), int2(2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW), int2(5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), int2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightW), int2(6, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ), int2(5, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), int2(6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), int2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), int2(5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightY), int2(7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), int2(4, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW), int2(1, 3));
+        }
+
+        [TestCompiler]
+        public static void int4_shuffle_result_3()
+        {
+            int4 a = int4(0, 1, 2, 3);
+            int4 b = int4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightY), int3(2, 7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.LeftW), int3(6, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightX), int3(2, 7, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), int3(5, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), int3(7, 6, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.LeftY), int3(3, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightX), int3(3, 5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightW), int3(3, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.RightZ), int3(6, 5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), int3(5, 4, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightW, ShuffleComponent.LeftX), int3(7, 7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightY), int3(6, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightW), int3(6, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightY), int3(3, 5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), int3(6, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW), int3(5, 1, 7));
+        }
+
+        [TestCompiler]
+        public static void int4_shuffle_result_4()
+        {
+            int4 a = int4(0, 1, 2, 3);
+            int4 b = int4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ), int4(1, 3, 4, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW, ShuffleComponent.RightZ, ShuffleComponent.RightZ), int4(5, 3, 6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.RightW, ShuffleComponent.LeftZ), int4(6, 6, 7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ), int4(4, 5, 2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), int4(6, 1, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightW), int4(4, 5, 5, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightW, ShuffleComponent.LeftX, ShuffleComponent.RightW), int4(1, 7, 0, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftX), int4(5, 0, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightW, ShuffleComponent.LeftW, ShuffleComponent.LeftY), int4(4, 7, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), int4(5, 4, 1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), int4(0, 2, 6, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightW, ShuffleComponent.RightW), int4(2, 5, 7, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ, ShuffleComponent.RightX), int4(3, 4, 2, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), int4(4, 0, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), int4(6, 4, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY), int4(3, 7, 1, 5));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..af04e8fca8485ae49b484f864bb59efda1778605
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 682471010e9050444948ecc9c69b3b0c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..627107c11feda6a59be1cfdcebbd6c81da0a21e0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs
@@ -0,0 +1,1229 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt4x2
+    {
+        [TestCompiler]
+        public static void int4x2_zero()
+        {
+            TestUtils.AreEqual(int4x2.zero.c0.x, 0);
+            TestUtils.AreEqual(int4x2.zero.c0.y, 0);
+            TestUtils.AreEqual(int4x2.zero.c0.z, 0);
+            TestUtils.AreEqual(int4x2.zero.c0.w, 0);
+            TestUtils.AreEqual(int4x2.zero.c1.x, 0);
+            TestUtils.AreEqual(int4x2.zero.c1.y, 0);
+            TestUtils.AreEqual(int4x2.zero.c1.z, 0);
+            TestUtils.AreEqual(int4x2.zero.c1.w, 0);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_equal_wide_wide()
+        {
+            int4x2 a0 = int4x2(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370);
+            int4x2 b0 = int4x2(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x2 a1 = int4x2(1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            int4x2 b1 = int4x2(1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x2 a2 = int4x2(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int4x2 b2 = int4x2(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x2 a3 = int4x2(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            int4x2 b3 = int4x2(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_equal_wide_scalar()
+        {
+            int4x2 a0 = int4x2(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277);
+            int b0 = (746972502);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x2 a1 = int4x2(1682018538, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077);
+            int b1 = (795585660);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x2 a2 = int4x2(442746747, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678);
+            int b2 = (1772925698);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x2 a3 = int4x2(1305479811, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832);
+            int b3 = (255635293);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int4x2 b0 = int4x2(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (1061805787);
+            int4x2 b1 = int4x2(1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (2003197687);
+            int4x2 b2 = int4x2(1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (367814403);
+            int4x2 b3 = int4x2(1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_not_equal_wide_wide()
+        {
+            int4x2 a0 = int4x2(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646);
+            int4x2 b0 = int4x2(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x2 a1 = int4x2(1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            int4x2 b1 = int4x2(1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x2 a2 = int4x2(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int4x2 b2 = int4x2(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x2 a3 = int4x2(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            int4x2 b3 = int4x2(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_not_equal_wide_scalar()
+        {
+            int4x2 a0 = int4x2(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450);
+            int b0 = (248693828);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x2 a1 = int4x2(2105962247, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883);
+            int b1 = (727205263);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x2 a2 = int4x2(1622176923, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685);
+            int b2 = (768370497);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x2 a3 = int4x2(904014575, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907);
+            int b3 = (384643370);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int4x2 b0 = int4x2(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (124108032);
+            int4x2 b1 = int4x2(1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (266984506);
+            int4x2 b2 = int4x2(2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (572038024);
+            int4x2 b3 = int4x2(1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_wide_wide()
+        {
+            int4x2 a0 = int4x2(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973);
+            int4x2 b0 = int4x2(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202);
+            bool4x2 r0 = bool4x2(false, true, false, false, false, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x2 a1 = int4x2(928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            int4x2 b1 = int4x2(2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x2 a2 = int4x2(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int4x2 b2 = int4x2(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool4x2 r2 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x2 a3 = int4x2(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            int4x2 b3 = int4x2(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool4x2 r3 = bool4x2(false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_wide_scalar()
+        {
+            int4x2 a0 = int4x2(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341);
+            int b0 = (1491216667);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x2 a1 = int4x2(840091491, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709);
+            int b1 = (469591900);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x2 a2 = int4x2(1286331950, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110);
+            int b2 = (380753337);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x2 a3 = int4x2(867559111, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996);
+            int b3 = (1703747625);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int4x2 b0 = int4x2(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255);
+            bool4x2 r0 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (111349251);
+            int4x2 b1 = int4x2(1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1027318999);
+            int4x2 b2 = int4x2(146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400);
+            bool4x2 r2 = bool4x2(false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (1329939911);
+            int4x2 b3 = int4x2(1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_wide_wide()
+        {
+            int4x2 a0 = int4x2(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550);
+            int4x2 b0 = int4x2(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742);
+            bool4x2 r0 = bool4x2(true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x2 a1 = int4x2(2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            int4x2 b1 = int4x2(910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool4x2 r1 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x2 a2 = int4x2(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int4x2 b2 = int4x2(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x2 a3 = int4x2(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            int4x2 b3 = int4x2(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool4x2 r3 = bool4x2(true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_wide_scalar()
+        {
+            int4x2 a0 = int4x2(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035);
+            int b0 = (438688675);
+            bool4x2 r0 = bool4x2(true, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x2 a1 = int4x2(2125058448, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211);
+            int b1 = (304028799);
+            bool4x2 r1 = bool4x2(true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x2 a2 = int4x2(2063134811, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419);
+            int b2 = (1577403353);
+            bool4x2 r2 = bool4x2(true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x2 a3 = int4x2(1058332184, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708);
+            int b3 = (524569092);
+            bool4x2 r3 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int4x2 b0 = int4x2(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (691047512);
+            int4x2 b1 = int4x2(741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1023307544);
+            int4x2 b2 = int4x2(1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900);
+            bool4x2 r2 = bool4x2(false, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (315569296);
+            int4x2 b3 = int4x2(292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844);
+            bool4x2 r3 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_equal_wide_wide()
+        {
+            int4x2 a0 = int4x2(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394);
+            int4x2 b0 = int4x2(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595);
+            bool4x2 r0 = bool4x2(false, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x2 a1 = int4x2(117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            int4x2 b1 = int4x2(1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool4x2 r1 = bool4x2(true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x2 a2 = int4x2(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int4x2 b2 = int4x2(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool4x2 r2 = bool4x2(true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x2 a3 = int4x2(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            int4x2 b3 = int4x2(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool4x2 r3 = bool4x2(false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_equal_wide_scalar()
+        {
+            int4x2 a0 = int4x2(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407);
+            int b0 = (1688048545);
+            bool4x2 r0 = bool4x2(false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x2 a1 = int4x2(1459242706, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948);
+            int b1 = (1745758438);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x2 a2 = int4x2(2017733017, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750);
+            int b2 = (804204255);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x2 a3 = int4x2(1258115260, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122);
+            int b3 = (20607406);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int4x2 b0 = int4x2(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (762067160);
+            int4x2 b1 = int4x2(11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309);
+            bool4x2 r1 = bool4x2(false, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (861890786);
+            int4x2 b2 = int4x2(478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850);
+            bool4x2 r2 = bool4x2(false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (830430286);
+            int4x2 b3 = int4x2(145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788);
+            bool4x2 r3 = bool4x2(false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_equal_wide_wide()
+        {
+            int4x2 a0 = int4x2(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546);
+            int4x2 b0 = int4x2(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862);
+            bool4x2 r0 = bool4x2(false, false, true, false, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x2 a1 = int4x2(1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            int4x2 b1 = int4x2(396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool4x2 r1 = bool4x2(true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x2 a2 = int4x2(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int4x2 b2 = int4x2(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool4x2 r2 = bool4x2(false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x2 a3 = int4x2(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            int4x2 b3 = int4x2(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool4x2 r3 = bool4x2(false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_equal_wide_scalar()
+        {
+            int4x2 a0 = int4x2(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894);
+            int b0 = (1470533736);
+            bool4x2 r0 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x2 a1 = int4x2(609211196, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021);
+            int b1 = (1604309397);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x2 a2 = int4x2(196833647, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607);
+            int b2 = (1596738181);
+            bool4x2 r2 = bool4x2(false, true, true, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x2 a3 = int4x2(1223010129, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090);
+            int b3 = (379014762);
+            bool4x2 r3 = bool4x2(true, true, false, true, true, false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int4x2 b0 = int4x2(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (1240253990);
+            int4x2 b1 = int4x2(1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577);
+            bool4x2 r1 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (173706579);
+            int4x2 b2 = int4x2(625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (233894308);
+            int4x2 b3 = int4x2(479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835);
+            bool4x2 r3 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_add_wide_wide()
+        {
+            int4x2 a0 = int4x2(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721);
+            int4x2 b0 = int4x2(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440);
+            int4x2 r0 = int4x2(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x2 a1 = int4x2(698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            int4x2 b1 = int4x2(1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            int4x2 r1 = int4x2(-2009504361, 1101613923, -799189804, 1384643660, -147610603, 749502583, 623052937, -1181627673);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x2 a2 = int4x2(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int4x2 b2 = int4x2(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int4x2 r2 = int4x2(-2116725070, -1148541136, 1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x2 a3 = int4x2(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            int4x2 b3 = int4x2(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            int4x2 r3 = int4x2(-1246101576, -1393575153, 1940611170, 1099044556, -1932199380, 1285092016, -1653104091, -537584005);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_add_wide_scalar()
+        {
+            int4x2 a0 = int4x2(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301);
+            int b0 = (2124409227);
+            int4x2 r0 = int4x2(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x2 a1 = int4x2(2003021861, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654);
+            int b1 = (1635971971);
+            int4x2 r1 = int4x2(-655973464, -1498597039, 1721418173, -1590842359, -1419608225, -1161318437, -931517840, -1563556671);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x2 a2 = int4x2(756559204, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260);
+            int b2 = (1818718931);
+            int4x2 r2 = int4x2(-1719689161, -1817324813, -865729444, -890492967, -1783405065, -1407654896, -771472132, -1898466105);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x2 a3 = int4x2(736972565, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516);
+            int b3 = (711894571);
+            int4x2 r3 = int4x2(1448867136, 1276152010, -1531336442, -2010235028, -1955066180, -1727372462, 1368643353, 984669087);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int4x2 b0 = int4x2(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072);
+            int4x2 r0 = int4x2(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (996031825);
+            int4x2 b1 = int4x2(1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489);
+            int4x2 r1 = int4x2(-1741160522, 1775806765, 2107573127, 1779078270, 2126195769, 1284311409, -1901251610, -1662351982);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (673263339);
+            int4x2 b2 = int4x2(1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839);
+            int4x2 r2 = int4x2(2142564213, 688119304, 1789900338, -2132840657, -2020713071, 863914640, 1980723107, 1593349178);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (2082229835);
+            int4x2 b3 = int4x2(1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222);
+            int4x2 r3 = int4x2(-220331887, -998813003, -1706896009, -1231316299, -724399762, -1098910821, -406590953, -370946239);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_sub_wide_wide()
+        {
+            int4x2 a0 = int4x2(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138);
+            int4x2 b0 = int4x2(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885);
+            int4x2 r0 = int4x2(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x2 a1 = int4x2(1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            int4x2 b1 = int4x2(71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            int4x2 r1 = int4x2(1234495882, -838948052, -732179165, -881462314, -50205903, -930193352, 120810088, 929308315);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x2 a2 = int4x2(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int4x2 b2 = int4x2(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int4x2 r2 = int4x2(-624402009, -165899077, -728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x2 a3 = int4x2(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            int4x2 b3 = int4x2(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            int4x2 r3 = int4x2(-183740135, 972642792, -549594154, -1468159992, -730634354, 1218011798, 1846728662, -555907518);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_sub_wide_scalar()
+        {
+            int4x2 a0 = int4x2(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815);
+            int b0 = (462232403);
+            int4x2 r0 = int4x2(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x2 a1 = int4x2(281174200, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635);
+            int b1 = (87530840);
+            int4x2 r1 = int4x2(193643360, 1826193591, 1954062496, 469709150, 1031520608, 1502845892, 731559349, 728851795);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x2 a2 = int4x2(815920639, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794);
+            int b2 = (1829033117);
+            int4x2 r2 = int4x2(-1013112478, -36231185, -715592568, -410095141, -551775928, 263746281, -1186796375, -223782323);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x2 a3 = int4x2(819644478, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500);
+            int b3 = (1468003019);
+            int4x2 r3 = int4x2(-648358541, -1339699833, -914508762, -450876048, 531741763, 549269739, 349988745, -187017519);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int4x2 b0 = int4x2(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277);
+            int4x2 r0 = int4x2(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (1789300421);
+            int4x2 b1 = int4x2(264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829);
+            int4x2 r1 = int4x2(1524587528, 557444354, -28812327, 360864312, 530554961, 711920025, 458577702, 1271188592);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (967128529);
+            int4x2 b2 = int4x2(344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709);
+            int4x2 r2 = int4x2(622462275, -115139389, 59261833, -849756594, 506787961, 4974031, 410015068, -734088180);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (1980098777);
+            int4x2 b3 = int4x2(730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041);
+            int4x2 r3 = int4x2(1250038225, 535700950, 1126528221, 1841262345, 966908349, 1262009247, 1473341387, 763650736);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mul_wide_wide()
+        {
+            int4x2 a0 = int4x2(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069);
+            int4x2 b0 = int4x2(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980);
+            int4x2 r0 = int4x2(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x2 a1 = int4x2(571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            int4x2 b1 = int4x2(1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            int4x2 r1 = int4x2(-1654168033, 2093463192, -1207506618, -1133560830, 990589280, -938173952, -1341723466, 1156600361);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x2 a2 = int4x2(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int4x2 b2 = int4x2(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int4x2 r2 = int4x2(649177976, 678952165, 1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x2 a3 = int4x2(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            int4x2 b3 = int4x2(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            int4x2 r3 = int4x2(1891467339, 335415735, 1128927428, -1656253776, -1433851638, 479369680, -366628060, -250163942);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mul_wide_scalar()
+        {
+            int4x2 a0 = int4x2(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909);
+            int b0 = (1476837906);
+            int4x2 r0 = int4x2(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x2 a1 = int4x2(975743632, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467);
+            int b1 = (573770299);
+            int4x2 r1 = int4x2(414773040, -699623085, 1045098929, -1129153454, 1954692228, 970215437, 1522404739, 631100697);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x2 a2 = int4x2(1186856590, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703);
+            int b2 = (890343818);
+            int4x2 r2 = int4x2(218605196, 908725324, -805080014, -1528445592, 1365477062, 1262261996, 2040090952, 691203142);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x2 a3 = int4x2(1613845584, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051);
+            int b3 = (76318055);
+            int4x2 r3 = int4x2(-1335460816, 1256424448, -545299589, 628661398, 357366566, 753276674, 2132219401, -825295347);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int4x2 b0 = int4x2(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146);
+            int4x2 r0 = int4x2(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (2105124483);
+            int4x2 b1 = int4x2(1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225);
+            int4x2 r1 = int4x2(-1028919216, 2084093460, 1286996821, 910923781, 1886305329, -1039959883, 644799552, 1815059427);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (994616533);
+            int4x2 b2 = int4x2(1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330);
+            int4x2 r2 = int4x2(585859259, 2021158292, 1046891801, -1941821535, -738776427, -1715252039, -160572189, 1259643370);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (1186460236);
+            int4x2 b3 = int4x2(657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873);
+            int4x2 r3 = int4x2(-901633076, -879300144, 1278776548, 1761940324, -675287412, 2049744268, -375297800, -1944395988);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_div_wide_wide()
+        {
+            int4x2 a0 = int4x2(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739);
+            int4x2 b0 = int4x2(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678);
+            int4x2 r0 = int4x2(1, 0, 0, 8, 0, 0, 2, 7);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x2 a1 = int4x2(499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            int4x2 b1 = int4x2(2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            int4x2 r1 = int4x2(0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x2 a2 = int4x2(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int4x2 b2 = int4x2(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int4x2 r2 = int4x2(1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x2 a3 = int4x2(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            int4x2 b3 = int4x2(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            int4x2 r3 = int4x2(2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_div_wide_scalar()
+        {
+            int4x2 a0 = int4x2(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253);
+            int b0 = (947861580);
+            int4x2 r0 = int4x2(0, 1, 0, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x2 a1 = int4x2(341995568, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372);
+            int b1 = (495895326);
+            int4x2 r1 = int4x2(0, 3, 3, 4, 4, 2, 1, 3);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x2 a2 = int4x2(1447236569, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924);
+            int b2 = (107215658);
+            int4x2 r2 = int4x2(13, 0, 8, 6, 11, 13, 16, 17);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x2 a3 = int4x2(1244966864, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348);
+            int b3 = (1200843642);
+            int4x2 r3 = int4x2(1, 0, 1, 1, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int4x2 b0 = int4x2(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032);
+            int4x2 r0 = int4x2(6, 0, 0, 0, 2, 0, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (81831373);
+            int4x2 b1 = int4x2(1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859);
+            int4x2 r1 = int4x2(0, 0, 1, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1653451772);
+            int4x2 b2 = int4x2(270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890);
+            int4x2 r2 = int4x2(6, 33, 0, 1, 1, 0, 2, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (351914083);
+            int4x2 b3 = int4x2(131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708);
+            int4x2 r3 = int4x2(2, 0, 0, 0, 1, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mod_wide_wide()
+        {
+            int4x2 a0 = int4x2(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532);
+            int4x2 b0 = int4x2(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806);
+            int4x2 r0 = int4x2(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x2 a1 = int4x2(778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            int4x2 b1 = int4x2(769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            int4x2 r1 = int4x2(9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x2 a2 = int4x2(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int4x2 b2 = int4x2(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int4x2 r2 = int4x2(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x2 a3 = int4x2(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            int4x2 b3 = int4x2(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            int4x2 r3 = int4x2(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mod_wide_scalar()
+        {
+            int4x2 a0 = int4x2(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899);
+            int b0 = (883951171);
+            int4x2 r0 = int4x2(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x2 a1 = int4x2(896587769, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717);
+            int b1 = (405208598);
+            int4x2 r1 = int4x2(86170573, 361927802, 148819739, 307112428, 172564850, 324442651, 275480547, 391863923);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x2 a2 = int4x2(165478511, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313);
+            int b2 = (647846716);
+            int4x2 r2 = int4x2(165478511, 267861283, 307136969, 280344567, 437088090, 488509689, 144280764, 377501313);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x2 a3 = int4x2(1778384846, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942);
+            int b3 = (1216011754);
+            int4x2 r3 = int4x2(562373092, 812183417, 1153802502, 426660116, 708698988, 665297470, 352079071, 834971188);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int4x2 b0 = int4x2(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265);
+            int4x2 r0 = int4x2(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (293460573);
+            int4x2 b1 = int4x2(1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342);
+            int4x2 r1 = int4x2(293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (797184687);
+            int4x2 b2 = int4x2(821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318);
+            int4x2 r2 = int4x2(797184687, 797184687, 797184687, 797184687, 182024723, 797184687, 1919391, 797184687);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (164578061);
+            int4x2 b3 = int4x2(730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733);
+            int4x2 r3 = int4x2(164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_plus()
+        {
+            int4x2 a0 = int4x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            int4x2 r0 = int4x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            TestUtils.AreEqual(+a0, r0);
+
+            int4x2 a1 = int4x2(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            int4x2 r1 = int4x2(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            TestUtils.AreEqual(+a1, r1);
+
+            int4x2 a2 = int4x2(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            int4x2 r2 = int4x2(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            TestUtils.AreEqual(+a2, r2);
+
+            int4x2 a3 = int4x2(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            int4x2 r3 = int4x2(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_neg()
+        {
+            int4x2 a0 = int4x2(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349);
+            int4x2 r0 = int4x2(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349);
+            TestUtils.AreEqual(-a0, r0);
+
+            int4x2 a1 = int4x2(1115028238, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094);
+            int4x2 r1 = int4x2(-1115028238, -694995093, -1542206286, -213087293, -243937487, -341522275, -841085242, -574159094);
+            TestUtils.AreEqual(-a1, r1);
+
+            int4x2 a2 = int4x2(1687250035, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928);
+            int4x2 r2 = int4x2(-1687250035, -1175014732, -1259809073, -1212465326, -1190569920, -2047955772, -2120729864, -1440774928);
+            TestUtils.AreEqual(-a2, r2);
+
+            int4x2 a3 = int4x2(1485596454, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098);
+            int4x2 r3 = int4x2(-1485596454, -1387601718, -1745651998, -319115626, -1119959806, -739132284, -1954173314, -1709857098);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_prefix_inc()
+        {
+            int4x2 a0 = int4x2(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442);
+            int4x2 r0 = int4x2(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443);
+            TestUtils.AreEqual(++a0, r0);
+
+            int4x2 a1 = int4x2(913293639, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683);
+            int4x2 r1 = int4x2(913293640, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684);
+            TestUtils.AreEqual(++a1, r1);
+
+            int4x2 a2 = int4x2(993189311, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865);
+            int4x2 r2 = int4x2(993189312, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866);
+            TestUtils.AreEqual(++a2, r2);
+
+            int4x2 a3 = int4x2(519296647, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208);
+            int4x2 r3 = int4x2(519296648, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_postfix_inc()
+        {
+            int4x2 a0 = int4x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            int4x2 r0 = int4x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            TestUtils.AreEqual(a0++, r0);
+
+            int4x2 a1 = int4x2(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            int4x2 r1 = int4x2(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            TestUtils.AreEqual(a1++, r1);
+
+            int4x2 a2 = int4x2(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            int4x2 r2 = int4x2(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            TestUtils.AreEqual(a2++, r2);
+
+            int4x2 a3 = int4x2(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            int4x2 r3 = int4x2(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_prefix_dec()
+        {
+            int4x2 a0 = int4x2(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826);
+            int4x2 r0 = int4x2(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825);
+            TestUtils.AreEqual(--a0, r0);
+
+            int4x2 a1 = int4x2(1434377580, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956);
+            int4x2 r1 = int4x2(1434377579, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955);
+            TestUtils.AreEqual(--a1, r1);
+
+            int4x2 a2 = int4x2(356565557, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829);
+            int4x2 r2 = int4x2(356565556, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828);
+            TestUtils.AreEqual(--a2, r2);
+
+            int4x2 a3 = int4x2(1454322707, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343);
+            int4x2 r3 = int4x2(1454322706, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_postfix_dec()
+        {
+            int4x2 a0 = int4x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            int4x2 r0 = int4x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            TestUtils.AreEqual(a0--, r0);
+
+            int4x2 a1 = int4x2(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            int4x2 r1 = int4x2(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            TestUtils.AreEqual(a1--, r1);
+
+            int4x2 a2 = int4x2(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            int4x2 r2 = int4x2(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            TestUtils.AreEqual(a2--, r2);
+
+            int4x2 a3 = int4x2(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            int4x2 r3 = int4x2(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_and_wide_wide()
+        {
+            int4x2 a0 = int4x2(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406);
+            int4x2 b0 = int4x2(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812);
+            int4x2 r0 = int4x2(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x2 a1 = int4x2(2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            int4x2 b1 = int4x2(23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            int4x2 r1 = int4x2(16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x2 a2 = int4x2(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int4x2 b2 = int4x2(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int4x2 r2 = int4x2(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x2 a3 = int4x2(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            int4x2 b3 = int4x2(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            int4x2 r3 = int4x2(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_and_wide_scalar()
+        {
+            int4x2 a0 = int4x2(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839);
+            int b0 = (93423598);
+            int4x2 r0 = int4x2(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x2 a1 = int4x2(1365509729, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033);
+            int b1 = (428270198);
+            int4x2 r1 = int4x2(285475424, 262144, 8536128, 134529558, 277234224, 150995062, 142909440, 285474848);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x2 a2 = int4x2(1408932942, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926);
+            int b2 = (957693145);
+            int4x2 r2 = int4x2(286268488, 420556880, 18167000, 286270481, 420753408, 134551616, 152314057, 420547656);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x2 a3 = int4x2(1817145060, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525);
+            int b3 = (1466722981);
+            int4x2 r3 = int4x2(1145858724, 1145069572, 273443365, 101460005, 1093403136, 524420, 335806629, 1142948357);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int4x2 b0 = int4x2(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279);
+            int4x2 r0 = int4x2(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1089518981);
+            int4x2 b1 = int4x2(270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038);
+            int4x2 r1 = int4x2(2105729, 1080066432, 40324, 1074831621, 1081121157, 1058177, 14593, 1084233092);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1845693112);
+            int4x2 b2 = int4x2(946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417);
+            int4x2 r2 = int4x2(671287840, 1141047992, 1744964224, 33751056, 1744964256, 1845559864, 1140852752, 1208158384);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1214109404);
+            int4x2 b3 = int4x2(2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506);
+            int4x2 r3 = int4x2(16988, 1208799884, 1074321052, 1209303624, 1115840, 1213727936, 1610312, 1078218760);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_or_wide_wide()
+        {
+            int4x2 a0 = int4x2(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835);
+            int4x2 b0 = int4x2(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430);
+            int4x2 r0 = int4x2(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x2 a1 = int4x2(669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            int4x2 b1 = int4x2(1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            int4x2 r1 = int4x2(1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x2 a2 = int4x2(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int4x2 b2 = int4x2(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int4x2 r2 = int4x2(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x2 a3 = int4x2(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            int4x2 b3 = int4x2(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            int4x2 r3 = int4x2(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_or_wide_scalar()
+        {
+            int4x2 a0 = int4x2(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250);
+            int b0 = (1666102508);
+            int4x2 r0 = int4x2(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x2 a1 = int4x2(860336789, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989);
+            int b1 = (1637162093);
+            int4x2 r1 = int4x2(1943518973, 1773477631, 1874321005, 1979522941, 1742175855, 1872100735, 1978998143, 1675623789);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x2 a2 = int4x2(1980838747, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359);
+            int b2 = (284225881);
+            int4x2 r2 = int4x2(1995567963, 334885881, 317847551, 1408563035, 1895366623, 536016891, 2029779967, 2063332319);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x2 a3 = int4x2(1511253082, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895);
+            int b3 = (1775629833);
+            int4x2 r3 = int4x2(2077750875, 1843265467, 1775761279, 2111176313, 2046817999, 2113404623, 1778251405, 2077753039);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int4x2 b0 = int4x2(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012);
+            int4x2 r0 = int4x2(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (979469710);
+            int4x2 b1 = int4x2(1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473);
+            int4x2 r1 = int4x2(2055064991, 2078664126, 1005832159, 1063386607, 1064023950, 989314559, 1056294302, 997187007);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (447949225);
+            int4x2 b2 = int4x2(527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150);
+            int4x2 r2 = int4x2(536590767, 2126457261, 447999469, 1526184941, 2062773753, 1593519101, 1589357545, 1526197231);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (298563808);
+            int4x2 b3 = int4x2(2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556);
+            int4x2 r3 = int4x2(2078276845, 872414207, 938213110, 1945092072, 1375468774, 838844392, 1004273386, 836763636);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_xor_wide_wide()
+        {
+            int4x2 a0 = int4x2(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553);
+            int4x2 b0 = int4x2(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262);
+            int4x2 r0 = int4x2(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x2 a1 = int4x2(47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            int4x2 b1 = int4x2(1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            int4x2 r1 = int4x2(1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x2 a2 = int4x2(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int4x2 b2 = int4x2(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int4x2 r2 = int4x2(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x2 a3 = int4x2(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            int4x2 b3 = int4x2(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            int4x2 r3 = int4x2(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_xor_wide_scalar()
+        {
+            int4x2 a0 = int4x2(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586);
+            int b0 = (493665894);
+            int4x2 r0 = int4x2(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x2 a1 = int4x2(1305234431, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978);
+            int b1 = (353786540);
+            int4x2 r1 = int4x2(1490686291, 1528187574, 1585863135, 309015380, 1534886006, 1913214449, 333543154, 57919030);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x2 a2 = int4x2(491079274, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736);
+            int b2 = (191750702);
+            int4x2 r2 = int4x2(371762244, 4897915, 852093491, 732592657, 763363694, 190966742, 1397197090, 1867453430);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x2 a3 = int4x2(447453839, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291);
+            int b3 = (890841598);
+            int4x2 r3 = int4x2(800240497, 610664066, 711808497, 714187902, 1735978412, 1929239075, 171965729, 427463573);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int4x2 b0 = int4x2(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737);
+            int4x2 r0 = int4x2(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1773918217);
+            int4x2 b1 = int4x2(1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937);
+            int4x2 r1 = int4x2(809875551, 777590045, 762148929, 497155858, 8071545, 440700667, 702609021, 2028559872);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (1382343363);
+            int4x2 b2 = int4x2(939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481);
+            int4x2 r2 = int4x2(1704743464, 476745462, 1598742512, 1722301941, 1981778335, 1509285046, 19333242, 1884605034);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (1813817520);
+            int4x2 b3 = int4x2(86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759);
+            int4x2 r3 = int4x2(1765145501, 465338881, 961174309, 1508358725, 916626445, 1734574159, 1183306712, 2052237431);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_left_shift()
+        {
+            int4x2 a0 = int4x2(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484);
+            int b0 = (1321149625);
+            int4x2 r0 = int4x2(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int4x2 a1 = int4x2(1200694230, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989);
+            int b1 = (1531607705);
+            int4x2 r1 = int4x2(-1409286144, -872415232, -1409286144, 1006632960, 1174405120, 503316480, -1677721600, -637534208);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int4x2 a2 = int4x2(2077023268, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278);
+            int b2 = (592678686);
+            int4x2 r2 = int4x2(0, -1073741824, -1073741824, -1073741824, 1073741824, 1073741824, 1073741824, -2147483648);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int4x2 a3 = int4x2(221147365, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688);
+            int b3 = (2084190583);
+            int4x2 r3 = int4x2(1920991232, -1342177280, -603979776, -134217728, -805306368, -310378496, 109051904, 1207959552);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_right_shift()
+        {
+            int4x2 a0 = int4x2(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998);
+            int b0 = (1266801540);
+            int4x2 r0 = int4x2(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int4x2 a1 = int4x2(572763124, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711);
+            int b1 = (506619530);
+            int4x2 r1 = int4x2(559338, 416804, 1983710, 685476, 896274, 556157, 181243, 1076292);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int4x2 a2 = int4x2(334005460, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760);
+            int b2 = (1624751550);
+            int4x2 r2 = int4x2(0, 0, 1, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int4x2 a3 = int4x2(348013684, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476);
+            int b3 = (1568185874);
+            int4x2 r3 = int4x2(1327, 2953, 6054, 2289, 112, 7175, 1343, 4442);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x2_operator_bitwise_not()
+        {
+            int4x2 a0 = int4x2(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856);
+            int4x2 r0 = int4x2(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857);
+            TestUtils.AreEqual(~a0, r0);
+
+            int4x2 a1 = int4x2(472965491, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466);
+            int4x2 r1 = int4x2(-472965492, -627580961, -2061524025, -753208489, -2097179284, -1303022494, -664744604, -1289372467);
+            TestUtils.AreEqual(~a1, r1);
+
+            int4x2 a2 = int4x2(1635981125, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942);
+            int4x2 r2 = int4x2(-1635981126, -1545651938, -717936458, -1284504688, -1342785386, -869629476, -2045854322, -1282546943);
+            TestUtils.AreEqual(~a2, r2);
+
+            int4x2 a3 = int4x2(1562433528, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039);
+            int4x2 r3 = int4x2(-1562433529, -1736570716, -508906059, -2060752881, -1867418757, -388530275, -695179853, -1766938040);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..fb8905d4e57834cbb8d6fbf604f7c312202ef3f2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a22ace1f6a955624aa145878a9d31bd2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..feabe99cfb007e6d0569e64012b1e85e7e576c7a
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs
@@ -0,0 +1,1233 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt4x3
+    {
+        [TestCompiler]
+        public static void int4x3_zero()
+        {
+            TestUtils.AreEqual(int4x3.zero.c0.x, 0);
+            TestUtils.AreEqual(int4x3.zero.c0.y, 0);
+            TestUtils.AreEqual(int4x3.zero.c0.z, 0);
+            TestUtils.AreEqual(int4x3.zero.c0.w, 0);
+            TestUtils.AreEqual(int4x3.zero.c1.x, 0);
+            TestUtils.AreEqual(int4x3.zero.c1.y, 0);
+            TestUtils.AreEqual(int4x3.zero.c1.z, 0);
+            TestUtils.AreEqual(int4x3.zero.c1.w, 0);
+            TestUtils.AreEqual(int4x3.zero.c2.x, 0);
+            TestUtils.AreEqual(int4x3.zero.c2.y, 0);
+            TestUtils.AreEqual(int4x3.zero.c2.z, 0);
+            TestUtils.AreEqual(int4x3.zero.c2.w, 0);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_equal_wide_wide()
+        {
+            int4x3 a0 = int4x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            int4x3 b0 = int4x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x3 a1 = int4x3(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            int4x3 b1 = int4x3(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x3 a2 = int4x3(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            int4x3 b2 = int4x3(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x3 a3 = int4x3(346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            int4x3 b3 = int4x3(1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_equal_wide_scalar()
+        {
+            int4x3 a0 = int4x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411);
+            int b0 = (746972502);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x3 a1 = int4x3(672785749, 585324157, 404448210, 969511077, 442746747, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005);
+            int b1 = (1465584610);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x3 a2 = int4x3(211986678, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291);
+            int b2 = (1305479811);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x3 a3 = int4x3(872759249, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886, 20195989);
+            int b3 = (811880239);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int4x3 b0 = int4x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (737210539);
+            int4x3 b1 = int4x3(1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (597498209);
+            int4x3 b2 = int4x3(367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (1576985758);
+            int4x3 b3 = int4x3(1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036, 2074160001);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_not_equal_wide_wide()
+        {
+            int4x3 a0 = int4x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            int4x3 b0 = int4x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x3 a1 = int4x3(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            int4x3 b1 = int4x3(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x3 a2 = int4x3(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            int4x3 b2 = int4x3(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x3 a3 = int4x3(1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            int4x3 b3 = int4x3(1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_not_equal_wide_scalar()
+        {
+            int4x3 a0 = int4x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906);
+            int b0 = (248693828);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x3 a1 = int4x3(2126300423, 2035077187, 1171827730, 1412347883, 1622176923, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766);
+            int b1 = (791998981);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x3 a2 = int4x3(30493685, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113);
+            int b2 = (904014575);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x3 a3 = int4x3(765258490, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942, 780105497);
+            int b3 = (668154629);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int4x3 b0 = int4x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (50286949);
+            int4x3 b1 = int4x3(2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (510966350);
+            int4x3 b2 = int4x3(572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (358894860);
+            int4x3 b3 = int4x3(1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167, 1002934795);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_wide_wide()
+        {
+            int4x3 a0 = int4x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            int4x3 b0 = int4x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool4x3 r0 = bool4x3(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x3 a1 = int4x3(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            int4x3 b1 = int4x3(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x3 a2 = int4x3(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            int4x3 b2 = int4x3(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool4x3 r2 = bool4x3(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x3 a3 = int4x3(1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            int4x3 b3 = int4x3(1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool4x3 r3 = bool4x3(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_wide_scalar()
+        {
+            int4x3 a0 = int4x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650);
+            int b0 = (1491216667);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x3 a1 = int4x3(930950514, 933855388, 908563901, 1127696709, 1286331950, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027);
+            int b1 = (1100560246);
+            bool4x3 r1 = bool4x3(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x3 a2 = int4x3(371987110, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606);
+            int b2 = (867559111);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x3 a3 = int4x3(1891059504, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493, 212954934);
+            int b3 = (1217893177);
+            bool4x3 r3 = bool4x3(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int4x3 b0 = int4x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311);
+            bool4x3 r0 = bool4x3(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1890019295);
+            int4x3 b1 = int4x3(2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659);
+            bool4x3 r1 = bool4x3(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (810406400);
+            int4x3 b2 = int4x3(1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916);
+            bool4x3 r2 = bool4x3(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (168788814);
+            int4x3 b3 = int4x3(670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033, 685700324);
+            bool4x3 r3 = bool4x3(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_wide_wide()
+        {
+            int4x3 a0 = int4x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            int4x3 b0 = int4x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool4x3 r0 = bool4x3(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x3 a1 = int4x3(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            int4x3 b1 = int4x3(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x3 a2 = int4x3(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            int4x3 b2 = int4x3(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x3 a3 = int4x3(194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            int4x3 b3 = int4x3(1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_wide_scalar()
+        {
+            int4x3 a0 = int4x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515);
+            int b0 = (438688675);
+            bool4x3 r0 = bool4x3(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x3 a1 = int4x3(711945018, 577943770, 572743717, 1016617211, 2063134811, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424);
+            int b1 = (1035679270);
+            bool4x3 r1 = bool4x3(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x3 a2 = int4x3(1045140419, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732);
+            int b2 = (1058332184);
+            bool4x3 r2 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x3 a3 = int4x3(1284938191, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269, 1930086291);
+            int b3 = (1452639553);
+            bool4x3 r3 = bool4x3(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int4x3 b0 = int4x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1556466996);
+            int4x3 b1 = int4x3(858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711);
+            bool4x3 r1 = bool4x3(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (1713088900);
+            int4x3 b2 = int4x3(315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (267985383);
+            int4x3 b3 = int4x3(126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217, 1480829811);
+            bool4x3 r3 = bool4x3(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_equal_wide_wide()
+        {
+            int4x3 a0 = int4x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            int4x3 b0 = int4x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool4x3 r0 = bool4x3(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x3 a1 = int4x3(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            int4x3 b1 = int4x3(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x3 a2 = int4x3(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            int4x3 b2 = int4x3(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool4x3 r2 = bool4x3(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x3 a3 = int4x3(1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            int4x3 b3 = int4x3(1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_equal_wide_scalar()
+        {
+            int4x3 a0 = int4x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763);
+            int b0 = (1688048545);
+            bool4x3 r0 = bool4x3(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x3 a1 = int4x3(690091301, 2091514001, 1857173043, 1617221948, 2017733017, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519);
+            int b1 = (1806172431);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x3 a2 = int4x3(1917813750, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244);
+            int b2 = (1258115260);
+            bool4x3 r2 = bool4x3(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x3 a3 = int4x3(426908235, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266, 1483727269);
+            int b3 = (1818566980);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int4x3 b0 = int4x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1293698493);
+            int4x3 b1 = int4x3(48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (601413850);
+            int4x3 b2 = int4x3(830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260);
+            bool4x3 r2 = bool4x3(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (733876180);
+            int4x3 b3 = int4x3(1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410, 1987696011);
+            bool4x3 r3 = bool4x3(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_equal_wide_wide()
+        {
+            int4x3 a0 = int4x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            int4x3 b0 = int4x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool4x3 r0 = bool4x3(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x3 a1 = int4x3(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            int4x3 b1 = int4x3(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x3 a2 = int4x3(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            int4x3 b2 = int4x3(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool4x3 r2 = bool4x3(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x3 a3 = int4x3(584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            int4x3 b3 = int4x3(2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_equal_wide_scalar()
+        {
+            int4x3 a0 = int4x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867);
+            int b0 = (1470533736);
+            bool4x3 r0 = bool4x3(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x3 a1 = int4x3(1419295004, 1819986195, 1460027917, 1646290021, 196833647, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862);
+            int b1 = (471843809);
+            bool4x3 r1 = bool4x3(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x3 a2 = int4x3(1449142607, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895);
+            int b2 = (1223010129);
+            bool4x3 r2 = bool4x3(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x3 a3 = int4x3(192092521, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700, 702382564);
+            int b3 = (909358617);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int4x3 b0 = int4x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (1214546726);
+            int4x3 b1 = int4x3(917376832, 303549425, 2111728811, 945321577, 173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189);
+            bool4x3 r1 = bool4x3(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (1336522452);
+            int4x3 b2 = int4x3(233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513);
+            bool4x3 r2 = bool4x3(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (474197678);
+            int4x3 b3 = int4x3(1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168, 1274079907);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_add_wide_wide()
+        {
+            int4x3 a0 = int4x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            int4x3 b0 = int4x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            int4x3 r0 = int4x3(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135, -2009504361, 1101613923, -799189804, 1384643660);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x3 a1 = int4x3(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            int4x3 b1 = int4x3(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            int4x3 r1 = int4x3(-147610603, 749502583, 623052937, -1181627673, -2116725070, -1148541136, 1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x3 a2 = int4x3(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            int4x3 b2 = int4x3(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            int4x3 r2 = int4x3(-1246101576, -1393575153, 1940611170, 1099044556, -1932199380, 1285092016, -1653104091, -537584005, 604086579, -2144211299, -668553705, -1620851127);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x3 a3 = int4x3(728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            int4x3 b3 = int4x3(1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            int4x3 r3 = int4x3(-1833755501, 1450246522, -1850179797, 1669976746, -938217892, 1917402232, 1548618217, -1431586812, -823896228, 2013864506, 348877644, -2052539555);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_add_wide_scalar()
+        {
+            int4x3 a0 = int4x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202);
+            int b0 = (2124409227);
+            int4x3 r0 = int4x3(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768, -167536208, -534586098, -1010159783, -2085111867);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x3 a1 = int4x3(1068152966, 1497676888, 1727477485, 1095438654, 756559204, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233);
+            int b1 = (1239387100);
+            int4x3 r1 = int4x3(-1987427230, -1557903308, -1328102711, -1960141542, 1995946304, -1236861265, 1898310652, -1445061275, -1469824798, 1932230400, -1986986727, -1350803963);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x3 a2 = int4x3(577782260, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190);
+            int b2 = (736972565);
+            int4x3 r2 = int4x3(1314754825, 1448867136, 1301230004, -1506258448, -1985157034, -1929988186, -1702294468, 1393721347, 1009747081, -1640861532, 1565295538, -1441184541);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x3 a3 = int4x3(2092767444, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914, 1340503111);
+            int b3 = (973587865);
+            int4x3 r3 = int4x3(-1228611987, -2084448158, 1477852314, 1767880439, -1803320750, -1716743107, 1328461282, 1658835762, 1201369005, 1294770382, -2110803517, -1980876320);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int4x3 b0 = int4x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302);
+            int4x3 r0 = int4x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146, 1387123903, 1948867027, 1170867018, 1502633380);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (783046445);
+            int4x3 b1 = int4x3(1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768);
+            int4x3 r1 = int4x3(1913210389, 1071326029, -2114236990, -1875337362, 1456309784, -2042619977, 797902410, 1899683444, -2023057551, -1910929965, 973697746, 2090506213);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (920085839);
+            int4x3 b2 = int4x3(2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886);
+            int4x3 r2 = int4x3(-1292651622, -1382475883, 2134010297, 1425927291, 1901507001, -1886543758, 2033912479, -1568734949, -1533090235, 1126696690, 1447057792, -2138521571);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1459523189);
+            int4x3 b3 = int4x3(965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031, 1275565021);
+            int4x3 r3 = int4x3(-1869703476, 1542365988, -1537040906, -1029634335, -856579916, 1874526575, -929139959, -2112573910, -2091195311, -1158220548, 1762899220, -1559879086);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_sub_wide_wide()
+        {
+            int4x3 a0 = int4x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            int4x3 b0 = int4x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            int4x3 r0 = int4x3(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747, 1234495882, -838948052, -732179165, -881462314);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x3 a1 = int4x3(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            int4x3 b1 = int4x3(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            int4x3 r1 = int4x3(-50205903, -930193352, 120810088, 929308315, -624402009, -165899077, -728396869, -162295434, 676719274, 647669761, 957134686, -776749401);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x3 a2 = int4x3(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            int4x3 b2 = int4x3(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            int4x3 r2 = int4x3(-183740135, 972642792, -549594154, -1468159992, -730634354, 1218011798, 1846728662, -555907518, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x3 a3 = int4x3(741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            int4x3 b3 = int4x3(1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            int4x3 r3 = int4x3(-345917539, 1650323877, 979082147, 182559134, -136395064, 1442113917, 8339009, 1379854326, -592461473, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_sub_wide_scalar()
+        {
+            int4x3 a0 = int4x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336);
+            int b0 = (462232403);
+            int4x3 r0 = int4x3(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412, -181058203, -374701563, 1451492028, 1579360933);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x3 a1 = int4x3(557239990, 1590376732, 819090189, 816382635, 815920639, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742);
+            int b1 = (1119051448);
+            int4x3 r1 = int4x3(-561811458, 471325284, -299961259, -302668813, -303130809, 709981669, 673750484, -5610899, 299886528, 158205741, 973727950, -476814706);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x3 a2 = int4x3(1605250794, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204);
+            int b2 = (819644478);
+            int4x3 r2 = int4x3(785606316, 648358541, -691341292, -266150221, 197482493, 1180100304, 1197628280, 998347286, 461341022, -142669623, 818388135, 130116726);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x3 a3 = int4x3(1835969317, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965, 941598524);
+            int b3 = (919015590);
+            int4x3 r3 = int4x3(916953727, 57931720, 385231016, 537764618, 635007122, -149211225, 1138816097, -160879011, -248582335, -315784179, 754253375, 22582934);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int4x3 b0 = int4x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748);
+            int4x3 r0 = int4x3(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128, -97766016, 1426821512, 459678338, -126578343);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (1428436109);
+            int4x3 b1 = int4x3(1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461);
+            int4x3 r1 = int4x3(169690649, 351055713, 97713390, 910324280, 461307580, 1083769855, 346168191, 520569413, -388449014, 968095541, 466281611, 871322648);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (1701216709);
+            int4x3 b2 = int4x3(1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026);
+            int4x3 r2 = int4x3(-278882068, 971156157, 256818882, 847646153, 1562380277, 688026281, 983127179, 1194459319, 484768668, 764903962, -296069746, -268765317);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (902880656);
+            int4x3 b3 = int4x3(1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072, 2066839749);
+            int4x3 r3 = int4x3(-258340041, -539584069, 279919891, 171911747, 288056815, -986898364, -15441696, 768950736, 689757548, -932569804, 381812584, -1163959093);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mul_wide_wide()
+        {
+            int4x3 a0 = int4x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            int4x3 b0 = int4x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            int4x3 r0 = int4x3(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068, -1654168033, 2093463192, -1207506618, -1133560830);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x3 a1 = int4x3(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            int4x3 b1 = int4x3(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            int4x3 r1 = int4x3(990589280, -938173952, -1341723466, 1156600361, 649177976, 678952165, 1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x3 a2 = int4x3(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            int4x3 b2 = int4x3(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            int4x3 r2 = int4x3(1891467339, 335415735, 1128927428, -1656253776, -1433851638, 479369680, -366628060, -250163942, 48406862, -1997863296, -275121228, -1483457191);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x3 a3 = int4x3(892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            int4x3 b3 = int4x3(142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            int4x3 r3 = int4x3(293009766, -617864326, 1179445736, -481780132, -1586128904, 1397450915, 487571412, -405680754, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mul_wide_scalar()
+        {
+            int4x3 a0 = int4x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747);
+            int b0 = (1476837906);
+            int4x3 r0 = int4x3(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518, 1736252960, -1699123674, -1534863838, -1853528010);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x3 a1 = int4x3(1818877398, 660611671, 1279757657, 391009467, 1186856590, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300);
+            int b1 = (1324050764);
+            int4x3 r1 = int4x3(1927061896, 645718228, -588613780, -844440956, -567685080, -1684615432, -1092253528, 133057916, -1582148944, -1029961452, -248833688, 100822256);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x3 a2 = int4x3(1192501703, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648);
+            int b2 = (1613845584);
+            int4x3 r2 = int4x3(-394864080, -1335460816, 692371456, 973833232, 1630959136, -1678368480, -191340960, 1516495024, 2027781488, 471196848, -2125435808, 1043640960);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x3 a3 = int4x3(227492421, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790, 396984449);
+            int b3 = (217698851);
+            int4x3 r3 = int4x3(269461871, 1120555251, 1293383984, 1838219542, -1271695412, 1677010101, 1900394426, 512258290, -238570208, -508870886, 1697920914, 1359963043);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int4x3 b0 = int4x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767);
+            int4x3 r0 = int4x3(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328, 1623617844, -1691554240, -830512240, -1283699420);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (243286231);
+            int4x3 b1 = int4x3(1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639);
+            int4x3 r1 = int4x3(-648389235, -1563629439, -401476800, -1314550601, 62369507, -76557479, -1413808100, -328103037, 2038656731, -2070911977, -1476360861, -1549578607);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (1323243330);
+            int4x3 b2 = int4x3(1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263);
+            int4x3 r2 = int4x3(-94024808, 50866050, 1979584376, -2129139002, 2084048518, -630615902, 1987582754, -2107012204, -1274032366, 1909741994, 2131645412, 527678350);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (2022856151);
+            int4x3 b3 = int4x3(1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370, 890235481);
+            int4x3 r3 = int4x3(-1935205669, -686991577, -1926794436, -1053293830, -653994693, -1849661752, 1198448575, -1186284852, -1561308297, -1930349931, -910321442, 938433983);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_div_wide_wide()
+        {
+            int4x3 a0 = int4x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            int4x3 b0 = int4x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            int4x3 r0 = int4x3(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x3 a1 = int4x3(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            int4x3 b1 = int4x3(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            int4x3 r1 = int4x3(0, 2, 1, 2, 1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x3 a2 = int4x3(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            int4x3 b2 = int4x3(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            int4x3 r2 = int4x3(2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x3 a3 = int4x3(991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            int4x3 b3 = int4x3(554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            int4x3 r3 = int4x3(1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_div_wide_scalar()
+        {
+            int4x3 a0 = int4x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657);
+            int b0 = (947861580);
+            int4x3 r0 = int4x3(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x3 a1 = int4x3(2131487088, 1017891310, 542666029, 1646044372, 1447236569, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885);
+            int b1 = (2105094094);
+            int4x3 r1 = int4x3(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x3 a2 = int4x3(1919705924, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918);
+            int b2 = (1244966864);
+            int4x3 r2 = int4x3(1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x3 a3 = int4x3(1515555001, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647, 1222061694);
+            int b3 = (614923813);
+            int4x3 r3 = int4x3(2, 1, 3, 3, 3, 1, 3, 0, 0, 2, 3, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int4x3 b0 = int4x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703);
+            int4x3 r0 = int4x3(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (631027637);
+            int4x3 b1 = int4x3(396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043);
+            int4x3 r1 = int4x3(1, 0, 0, 0, 0, 2, 12, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (1054404890);
+            int4x3 b2 = int4x3(351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534);
+            int4x3 r2 = int4x3(2, 7, 0, 2, 0, 4, 0, 0, 0, 23, 0, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (126616016);
+            int4x3 b3 = int4x3(1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719, 638134699);
+            int4x3 r3 = int4x3(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mod_wide_wide()
+        {
+            int4x3 a0 = int4x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            int4x3 b0 = int4x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            int4x3 r0 = int4x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x3 a1 = int4x3(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            int4x3 b1 = int4x3(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            int4x3 r1 = int4x3(137194997, 593433700, 360454892, 8060301, 7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x3 a2 = int4x3(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            int4x3 b2 = int4x3(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            int4x3 r2 = int4x3(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x3 a3 = int4x3(1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            int4x3 b3 = int4x3(244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            int4x3 r3 = int4x3(166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mod_wide_scalar()
+        {
+            int4x3 a0 = int4x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935);
+            int b0 = (883951171);
+            int4x3 r0 = int4x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x3 a1 = int4x3(712321026, 1540068445, 1085897743, 1607489717, 165478511, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912);
+            int b1 = (172564850);
+            int4x3 r1 = int4x3(22061626, 159549645, 50508643, 54406067, 165478511, 130152166, 52883749, 49746751, 65367033, 49545706, 143379989, 17042712);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x3 a2 = int4x3(377501313, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372);
+            int b2 = (1778384846);
+            int4x3 r2 = int4x3(377501313, 1216011754, 812183417, 1153802502, 1642671870, 146325896, 665297470, 1568090825, 272598096, 435886407, 453990946, 1731665372);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x3 a3 = int4x3(586777590, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411, 1524342239);
+            int b3 = (1475597526);
+            int4x3 r3 = int4x3(586777590, 110051989, 1414579860, 416067455, 1262495021, 1400758118, 53934482, 430295164, 1386414018, 654749032, 666621411, 48744713);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int4x3 b0 = int4x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233);
+            int4x3 r0 = int4x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1298102643);
+            int4x3 b1 = int4x3(2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738);
+            int4x3 r1 = int4x3(1298102643, 297360552, 1298102643, 1298102643, 500917956, 476213801, 214909646, 457987657, 1298102643, 67782715, 1298102643, 1739061);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (2122220318);
+            int4x3 b2 = int4x3(164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894);
+            int4x3 r2 = int4x3(147283586, 662044080, 677274179, 816428281, 1011391307, 376773156, 120051662, 644373900, 76505386, 479992776, 159909553, 50931378);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1342085447);
+            int4x3 b3 = int4x3(448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751, 1648646354);
+            int4x3 r3 = int4x3(445362875, 3415371, 636619696, 588996674, 195741437, 241524871, 267605306, 1342085447, 1342085447, 1342085447, 243643696, 1342085447);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_plus()
+        {
+            int4x3 a0 = int4x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            int4x3 r0 = int4x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            TestUtils.AreEqual(+a0, r0);
+
+            int4x3 a1 = int4x3(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            int4x3 r1 = int4x3(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            TestUtils.AreEqual(+a1, r1);
+
+            int4x3 a2 = int4x3(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            int4x3 r2 = int4x3(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            TestUtils.AreEqual(+a2, r2);
+
+            int4x3 a3 = int4x3(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            int4x3 r3 = int4x3(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_neg()
+        {
+            int4x3 a0 = int4x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286);
+            int4x3 r0 = int4x3(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349, -1115028238, -1636274969, -694995093, -1542206286);
+            TestUtils.AreEqual(-a0, r0);
+
+            int4x3 a1 = int4x3(213087293, 341522275, 841085242, 574159094, 1687250035, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864);
+            int4x3 r1 = int4x3(-213087293, -341522275, -841085242, -574159094, -1687250035, -2057919693, -1175014732, -1259809073, -1212465326, -1190569920, -2047955772, -2120729864);
+            TestUtils.AreEqual(-a1, r1);
+
+            int4x3 a2 = int4x3(1440774928, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868);
+            int4x3 r2 = int4x3(-1440774928, -431666091, -1387601718, -1745651998, -319115626, -1119959806, -739132284, -1954173314, -1709857098, -1836511050, -1662806453, -506144868);
+            TestUtils.AreEqual(-a2, r2);
+
+            int4x3 a3 = int4x3(650922971, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551, 1768435578);
+            int4x3 r3 = int4x3(-650922971, -1273997249, -1474445187, -1853826947, -1695573773, -729452512, -345069360, -575867536, -594119038, -1201840609, -1342872551, -1768435578);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_prefix_inc()
+        {
+            int4x3 a0 = int4x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935);
+            int4x3 r0 = int4x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936);
+            TestUtils.AreEqual(++a0, r0);
+
+            int4x3 a1 = int4x3(1835605516, 388229350, 696475402, 1786514683, 993189311, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489);
+            int4x3 r1 = int4x3(1835605517, 388229351, 696475403, 1786514684, 993189312, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490);
+            TestUtils.AreEqual(++a1, r1);
+
+            int4x3 a2 = int4x3(504806865, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111);
+            int4x3 r2 = int4x3(504806866, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112);
+            TestUtils.AreEqual(++a2, r2);
+
+            int4x3 a3 = int4x3(1414867743, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802, 413165245);
+            int4x3 r3 = int4x3(1414867744, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803, 413165246);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_postfix_inc()
+        {
+            int4x3 a0 = int4x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            int4x3 r0 = int4x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            TestUtils.AreEqual(a0++, r0);
+
+            int4x3 a1 = int4x3(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            int4x3 r1 = int4x3(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            TestUtils.AreEqual(a1++, r1);
+
+            int4x3 a2 = int4x3(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            int4x3 r2 = int4x3(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            TestUtils.AreEqual(a2++, r2);
+
+            int4x3 a3 = int4x3(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            int4x3 r3 = int4x3(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_prefix_dec()
+        {
+            int4x3 a0 = int4x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358);
+            int4x3 r0 = int4x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357);
+            TestUtils.AreEqual(--a0, r0);
+
+            int4x3 a1 = int4x3(1914114460, 389120307, 1022184392, 1310293956, 356565557, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297);
+            int4x3 r1 = int4x3(1914114459, 389120306, 1022184391, 1310293955, 356565556, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296);
+            TestUtils.AreEqual(--a1, r1);
+
+            int4x3 a2 = int4x3(220897829, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380);
+            int4x3 r2 = int4x3(220897828, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379);
+            TestUtils.AreEqual(--a2, r2);
+
+            int4x3 a3 = int4x3(2083512379, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317, 767990877);
+            int4x3 r3 = int4x3(2083512378, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316, 767990876);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_postfix_dec()
+        {
+            int4x3 a0 = int4x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            int4x3 r0 = int4x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            TestUtils.AreEqual(a0--, r0);
+
+            int4x3 a1 = int4x3(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            int4x3 r1 = int4x3(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            TestUtils.AreEqual(a1--, r1);
+
+            int4x3 a2 = int4x3(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            int4x3 r2 = int4x3(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            TestUtils.AreEqual(a2--, r2);
+
+            int4x3 a3 = int4x3(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            int4x3 r3 = int4x3(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_and_wide_wide()
+        {
+            int4x3 a0 = int4x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            int4x3 b0 = int4x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            int4x3 r0 = int4x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x3 a1 = int4x3(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            int4x3 b1 = int4x3(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            int4x3 r1 = int4x3(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x3 a2 = int4x3(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            int4x3 b2 = int4x3(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            int4x3 r2 = int4x3(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x3 a3 = int4x3(1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            int4x3 b3 = int4x3(1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            int4x3 r3 = int4x3(706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_and_wide_scalar()
+        {
+            int4x3 a0 = int4x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920);
+            int b0 = (93423598);
+            int4x3 r0 = int4x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x3 a1 = int4x3(1249238550, 1862276471, 143502472, 861733033, 1408932942, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025);
+            int b1 = (814629680);
+            int4x3 r1 = int4x3(279056, 536871216, 9175040, 806092832, 277479424, 805568528, 268452112, 9175824, 268567088, 268697600, 934144, 8650784);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x3 a2 = int4x3(462670926, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061);
+            int b2 = (1817145060);
+            int4x3 r2 = int4x3(134433860, 1145858724, 1816224836, 542076516, 739126372, 1611530816, 537593028, 604439716, 1140983364, 672014980, 1745571424, 1208165380);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x3 a3 = int4x3(398141788, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172, 1826788967);
+            int b3 = (156911041);
+            int4x3 r3 = int4x3(18481472, 17843457, 5783937, 156763393, 22151233, 138937729, 152585345, 4867329, 21643264, 132544, 4719616, 138544193);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int4x3 b0 = int4x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596);
+            int4x3 r0 = int4x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1763483957);
+            int4x3 b1 = int4x3(1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366);
+            int4x3 r1 = int4x3(1209041205, 136061185, 151265585, 1074528516, 1744830512, 671121697, 1092091952, 1761607941, 18391060, 1761615904, 1763221553, 1091051540);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (1233066417);
+            int4x3 b2 = int4x3(1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007);
+            int4x3 r2 = int4x3(1214058640, 2230321, 1210847617, 1074401680, 1211367456, 1116577, 1232603553, 3674113, 1078202400, 136118672, 1098518961, 4128897);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1808619374);
+            int4x3 b3 = int4x3(1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681, 1980296380);
+            int4x3 r3 = int4x3(1246058336, 1644778764, 12650346, 1640318254, 1216610624, 587220044, 1644695918, 33834028, 734795298, 671961678, 1241777216, 1644708908);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_or_wide_wide()
+        {
+            int4x3 a0 = int4x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            int4x3 b0 = int4x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            int4x3 r0 = int4x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x3 a1 = int4x3(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            int4x3 b1 = int4x3(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            int4x3 r1 = int4x3(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x3 a2 = int4x3(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            int4x3 b2 = int4x3(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            int4x3 r2 = int4x3(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x3 a3 = int4x3(470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            int4x3 b3 = int4x3(1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            int4x3 r3 = int4x3(1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_or_wide_scalar()
+        {
+            int4x3 a0 = int4x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856);
+            int b0 = (1666102508);
+            int4x3 r0 = int4x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x3 a1 = int4x3(879300408, 797240690, 1977614655, 46921989, 1980838747, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070);
+            int b1 = (1179087439);
+            int4x3 r1 = int4x3(1987018623, 1875378047, 2011657087, 1188035407, 1985442655, 1459090271, 1205302255, 1459058687, 1465382751, 1995407311, 1599567599, 2122316799);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x3 a2 = int4x3(2055963359, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200);
+            int b2 = (1511253082);
+            int4x3 r2 = int4x3(2057037535, 2077750875, 1579155451, 2069362559, 1590951034, 1534850271, 1593306847, 2050745566, 1519910623, 2117597023, 1604316378, 1600120154);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x3 a3 = int4x3(1353013374, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643, 142082352);
+            int b3 = (1349149982);
+            int4x3 r3 = int4x3(1357872510, 1895528286, 1374318015, 2012964638, 1550483390, 1602123263, 1483666815, 1920624063, 1458464191, 2012116286, 1424685023, 1484416318);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int4x3 b0 = int4x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649);
+            int4x3 r0 = int4x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (1059093741);
+            int4x3 b1 = int4x3(627815046, 418822515, 83214352, 424663473, 447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329);
+            int4x3 r1 = int4x3(1064042223, 1073151487, 1073085693, 1064304125, 1068727789, 1063910895, 2133818605, 1060240621, 2145910509, 2138209533, 2146074365, 2142830317);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (1088734150);
+            int4x3 b2 = int4x3(298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598);
+            int4x3 r2 = int4x3(1374682086, 2063067087, 1660812255, 1743570934, 1945042926, 1089859558, 1911943150, 2079645678, 1627375606, 1307434967, 1341444039, 1526649806);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (1098359242);
+            int4x3 b3 = int4x3(997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616, 1326199854);
+            int4x3 r3 = int4x3(2071978954, 1098885598, 2071455727, 1702356954, 1098381823, 1568651246, 2046802926, 1509946863, 2038414794, 1644161007, 1308081658, 1333769710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_xor_wide_wide()
+        {
+            int4x3 a0 = int4x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            int4x3 b0 = int4x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            int4x3 r0 = int4x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x3 a1 = int4x3(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            int4x3 b1 = int4x3(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            int4x3 r1 = int4x3(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x3 a2 = int4x3(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            int4x3 b2 = int4x3(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            int4x3 r2 = int4x3(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x3 a3 = int4x3(1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            int4x3 b3 = int4x3(1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            int4x3 r3 = int4x3(632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_xor_wide_scalar()
+        {
+            int4x3 a0 = int4x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267);
+            int b0 = (493665894);
+            int4x3 r0 = int4x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x3 a1 = int4x3(125659640, 1730088797, 116862046, 375757978, 491079274, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924);
+            int b1 = (1315625690);
+            int4x3 r1 = int4x3(1226289954, 695588231, 1218311812, 1477396032, 1395629232, 1158101236, 1162708111, 2010043079, 1856848613, 1753692570, 1315361570, 373338582);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x3 a2 = int4x3(1680011736, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239);
+            int b2 = (447453839);
+            int4x3 r2 = int4x3(2122935127, 800240497, 198659571, 98559616, 86185743, 1221222109, 1565485394, 630017616, 919085284, 427397619, 1988160398, 446789440);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x3 a3 = int4x3(476052372, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185, 1771744425);
+            int b3 = (92561487);
+            int4x3 r3 = int4x3(433822683, 2133436125, 133297725, 1274987888, 2020970994, 180462097, 52620731, 1114759625, 2024733453, 2005017615, 912470822, 1813957862);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int4x3 b0 = int4x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424);
+            int4x3 r0 = int4x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (1947871003);
+            int4x3 b1 = int4x3(1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881);
+            int4x3 r1 = int4x3(500881003, 132477417, 876677487, 1699258642, 645842392, 1138923504, 974408494, 2033457704, 1087830061, 1348553799, 2139822446, 660194722);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (573581481);
+            int4x3 b2 = int4x3(1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615);
+            int4x3 r2 = int4x3(1311539225, 655981444, 1435501080, 2003229500, 399194716, 2022579220, 693043286, 145445825, 880683118, 787181808, 2146955403, 205673470);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (711527976);
+            int4x3 b3 = int4x3(710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645, 896851285);
+            int4x3 r3 = int4x3(3284335, 658000982, 154339351, 2085169939, 946304861, 44451568, 2115414221, 2137251591, 317021346, 552683235, 1575100285, 522048381);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_left_shift()
+        {
+            int4x3 a0 = int4x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534);
+            int b0 = (1321149625);
+            int4x3 r0 = int4x3(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464, -1409286144, 838860800, -872415232, -1409286144);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int4x3 a1 = int4x3(1447702302, 35667343, 1664454606, 2045594989, 2077023268, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181);
+            int b1 = (1079614371);
+            int4x3 r1 = int4x3(-1303283472, 285338744, 430734960, -815109272, -563683040, 446462192, -1912924008, 897198008, 703071480, 298127560, -607585048, -711260440);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int4x3 a2 = int4x3(263886278, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192);
+            int b2 = (221147365);
+            int4x3 r2 = int4x3(-145573696, -2025378080, -1200788480, -2010056960, -1775845888, -1021463552, 1296563040, -1738194528, 1884213760, -928070976, 160790208, 31956480);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int4x3 a3 = int4x3(740058147, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326, 1996060114);
+            int b3 = (946058001);
+            int4x3 r3 = int4x3(-934936576, -87949312, 1441398784, -1265369088, -5373952, -1576271872, -614334464, 1110573056, 1163132928, 173408256, 1445724160, -341573632);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_right_shift()
+        {
+            int4x3 a0 = int4x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045);
+            int b0 = (1266801540);
+            int4x3 r0 = int4x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int4x3 a1 = int4x3(701927980, 569504877, 185593382, 1102123711, 334005460, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762);
+            int b1 = (917785020);
+            int4x3 r1 = int4x3(2, 2, 0, 4, 1, 6, 1, 5, 6, 2, 4, 1);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int4x3 a2 = int4x3(763607760, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381);
+            int b2 = (348013684);
+            int4x3 r2 = int4x3(728, 1495, 738, 1513, 572, 28, 1793, 335, 1110, 405, 177, 1048);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int4x3 a3 = int4x3(1234295294, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981, 1435331003);
+            int b3 = (1028666766);
+            int4x3 r3 = int4x3(75335, 46488, 76590, 55139, 72040, 11168, 58514, 65650, 86028, 96236, 42779, 87605);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x3_operator_bitwise_not()
+        {
+            int4x3 a0 = int4x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024);
+            int4x3 r0 = int4x3(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857, -472965492, -771711427, -627580961, -2061524025);
+            TestUtils.AreEqual(~a0, r0);
+
+            int4x3 a1 = int4x3(753208488, 1303022493, 664744603, 1289372466, 1635981125, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321);
+            int4x3 r1 = int4x3(-753208489, -1303022494, -664744604, -1289372467, -1635981126, -1951018597, -1545651938, -717936458, -1284504688, -1342785386, -869629476, -2045854322);
+            TestUtils.AreEqual(~a1, r1);
+
+            int4x3 a2 = int4x3(1282546942, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829);
+            int4x3 r2 = int4x3(-1282546943, -1824824811, -1736570716, -508906059, -2060752881, -1867418757, -388530275, -695179853, -1766938040, -897923627, -1816190465, -1362906830);
+            TestUtils.AreEqual(~a2, r2);
+
+            int4x3 a3 = int4x3(1227946838, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010, 722020848);
+            int4x3 r3 = int4x3(-1227946839, -189609279, -956441809, -2123488811, -1593014252, -19223062, -1722107955, -1636875695, -1914097393, -1382545028, -1285277011, -722020849);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..2a973318bfb75d128d5ddb56fd27903b68b47c79
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ffba8e003136db4abab4542f240e632
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..61036b7b485a6878a4dc30e7710723ddad86482d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs
@@ -0,0 +1,1258 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestInt4x4
+    {
+        [TestCompiler]
+        public static void int4x4_zero()
+        {
+            TestUtils.AreEqual(int4x4.zero.c0.x, 0);
+            TestUtils.AreEqual(int4x4.zero.c0.y, 0);
+            TestUtils.AreEqual(int4x4.zero.c0.z, 0);
+            TestUtils.AreEqual(int4x4.zero.c0.w, 0);
+            TestUtils.AreEqual(int4x4.zero.c1.x, 0);
+            TestUtils.AreEqual(int4x4.zero.c1.y, 0);
+            TestUtils.AreEqual(int4x4.zero.c1.z, 0);
+            TestUtils.AreEqual(int4x4.zero.c1.w, 0);
+            TestUtils.AreEqual(int4x4.zero.c2.x, 0);
+            TestUtils.AreEqual(int4x4.zero.c2.y, 0);
+            TestUtils.AreEqual(int4x4.zero.c2.z, 0);
+            TestUtils.AreEqual(int4x4.zero.c2.w, 0);
+            TestUtils.AreEqual(int4x4.zero.c3.x, 0);
+            TestUtils.AreEqual(int4x4.zero.c3.y, 0);
+            TestUtils.AreEqual(int4x4.zero.c3.z, 0);
+            TestUtils.AreEqual(int4x4.zero.c3.w, 0);
+        }
+
+        [TestCompiler]
+        public static void int4x4_identity()
+        {
+            TestUtils.AreEqual(int4x4.identity.c0.x, 1);
+            TestUtils.AreEqual(int4x4.identity.c0.y, 0);
+            TestUtils.AreEqual(int4x4.identity.c0.z, 0);
+            TestUtils.AreEqual(int4x4.identity.c0.w, 0);
+            TestUtils.AreEqual(int4x4.identity.c1.x, 0);
+            TestUtils.AreEqual(int4x4.identity.c1.y, 1);
+            TestUtils.AreEqual(int4x4.identity.c1.z, 0);
+            TestUtils.AreEqual(int4x4.identity.c1.w, 0);
+            TestUtils.AreEqual(int4x4.identity.c2.x, 0);
+            TestUtils.AreEqual(int4x4.identity.c2.y, 0);
+            TestUtils.AreEqual(int4x4.identity.c2.z, 1);
+            TestUtils.AreEqual(int4x4.identity.c2.w, 0);
+            TestUtils.AreEqual(int4x4.identity.c3.x, 0);
+            TestUtils.AreEqual(int4x4.identity.c3.y, 0);
+            TestUtils.AreEqual(int4x4.identity.c3.z, 0);
+            TestUtils.AreEqual(int4x4.identity.c3.w, 1);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_equal_wide_wide()
+        {
+            int4x4 a0 = int4x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            int4x4 b0 = int4x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x4 a1 = int4x4(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509, 1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            int4x4 b1 = int4x4(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580, 708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x4 a2 = int4x4(929607871, 2092475304, 1940221590, 196567546, 346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            int4x4 b2 = int4x4(91580624, 1974459648, 2074899534, 164782857, 1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x4 a3 = int4x4(1006521329, 850817587, 270689979, 182908990, 512098264, 1555870818, 1824899010, 913664406, 38410741, 1365981133, 1517827659, 698699317, 522637780, 2135467596, 1812545145, 795262261);
+            int4x4 b3 = int4x4(407784873, 516627611, 184196508, 1098113599, 1930819007, 693573550, 780517021, 48392683, 638156511, 356540844, 86920844, 103170762, 1952606997, 1374974056, 906153405, 602525178);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_equal_wide_scalar()
+        {
+            int4x4 a0 = int4x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210);
+            int b0 = (746972502);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int4x4 a1 = int4x4(969511077, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678, 1305479811, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966);
+            int b1 = (442746747);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int4x4 a2 = int4x4(1684122010, 172230876, 496695881, 955604291, 872759249, 811880239, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886);
+            int b2 = (1962874832);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int4x4 a3 = int4x4(20195989, 1256964339, 165389004, 759951440, 321496427, 551284899, 2058550111, 2146975562, 1182607877, 1588866146, 1478019984, 733564558, 1504896105, 284238873, 1641065069, 259620445);
+            int b3 = (550465422);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_equal_scalar_wide()
+        {
+            int a0 = (1150044438);
+            int4x4 b0 = int4x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            int a1 = (455818693);
+            int4x4 b1 = int4x4(2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            int a2 = (1395605233);
+            int4x4 b2 = int4x4(1191785903, 1156248212, 338891967, 61410415, 1576985758, 1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            int a3 = (2074160001);
+            int4x4 b3 = int4x4(211145132, 1330427155, 231737739, 590220146, 622950505, 2048231874, 682985774, 865101790, 1523019859, 261373300, 132547968, 1971091157, 982104573, 1456888767, 1700538931, 1590557254);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_not_equal_wide_wide()
+        {
+            int4x4 a0 = int4x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            int4x4 b0 = int4x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x4 a1 = int4x4(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890, 922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            int4x4 b1 = int4x4(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634, 1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x4 a2 = int4x4(10845678, 1588544505, 709736932, 1892341087, 1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            int4x4 b2 = int4x4(1954996717, 572153302, 865957902, 1083128726, 1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x4 a3 = int4x4(1370971537, 526135879, 1693615335, 1040142702, 51869182, 636351650, 1137389277, 742650911, 1652337799, 128512016, 943930500, 1281758501, 1506504768, 1142416208, 489425068, 709011851);
+            int4x4 b3 = int4x4(881583266, 836740859, 2050520235, 56355243, 923319881, 2093941797, 1966851287, 740544328, 1686486765, 1564852763, 1583872597, 1319685687, 1082069798, 1934459521, 610009662, 2003062130);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_not_equal_wide_scalar()
+        {
+            int4x4 a0 = int4x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730);
+            int b0 = (248693828);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int4x4 a1 = int4x4(1412347883, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685, 904014575, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847);
+            int b1 = (1622176923);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int4x4 a2 = int4x4(1555396158, 1739138988, 1916670251, 1516209113, 765258490, 668154629, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942);
+            int b2 = (913218907);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int4x4 a3 = int4x4(780105497, 1311007738, 2079744789, 1086529117, 898347399, 1597839770, 1711183709, 2048684031, 1167351404, 528657884, 565527393, 227149840, 89869060, 1358928288, 44374114, 2059875706);
+            int b3 = (1302143939);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_not_equal_scalar_wide()
+        {
+            int a0 = (2076921066);
+            int4x4 b0 = int4x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            int a1 = (472172806);
+            int4x4 b1 = int4x4(266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            int a2 = (676012224);
+            int4x4 b2 = int4x4(627370253, 1715733805, 699755913, 1875151666, 358894860, 1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            int a3 = (1002934795);
+            int4x4 b3 = int4x4(1859322106, 1990390938, 1674000894, 1035504906, 1681354617, 2079296301, 1396396873, 2128571831, 3388167, 1211711140, 575696152, 1534939377, 496306248, 908210564, 131274243, 543089960);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_wide_wide()
+        {
+            int4x4 a0 = int4x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            int4x4 b0 = int4x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool4x4 r0 = bool4x4(false, true, false, false, false, true, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x4 a1 = int4x4(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162, 1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            int4x4 b1 = int4x4(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133, 271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool4x4 r1 = bool4x4(true, true, true, true, false, false, true, true, false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x4 a2 = int4x4(410751553, 198134393, 1999935258, 671192178, 1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            int4x4 b2 = int4x4(833499488, 1999487070, 836063897, 1987309319, 1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool4x4 r2 = bool4x4(true, true, false, true, false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x4 a3 = int4x4(1772570968, 339779528, 1817654169, 126606875, 1748258817, 1840719780, 603645478, 1888655831, 63356146, 79832055, 736652918, 653392827, 423681122, 1242116477, 422099316, 898587272);
+            int4x4 b3 = int4x4(1951703613, 873360222, 2076434739, 802037827, 57389233, 1812417589, 13678411, 1415564189, 983023904, 1112076825, 2078443288, 1990790258, 482361677, 1981894392, 351965695, 585483077);
+            bool4x4 r3 = bool4x4(true, true, true, true, false, false, false, false, true, true, true, true, true, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_wide_scalar()
+        {
+            int4x4 a0 = int4x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901);
+            int b0 = (1491216667);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, false, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int4x4 a1 = int4x4(1127696709, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110, 867559111, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092);
+            int b1 = (1286331950);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int4x4 a2 = int4x4(118750042, 452204442, 1645191336, 1829152606, 1891059504, 1217893177, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493);
+            int b2 = (1829327996);
+            bool4x4 r2 = bool4x4(true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int4x4 a3 = int4x4(212954934, 1031281872, 1389987778, 928043903, 434566816, 1386588061, 180174416, 119231358, 842513438, 494182092, 2110901808, 2064339655, 798375285, 225918038, 2119961960, 1851740205);
+            int b3 = (519181838);
+            bool4x4 r3 = bool4x4(true, false, false, false, true, false, true, true, false, true, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_scalar_wide()
+        {
+            int a0 = (548436837);
+            int4x4 b0 = int4x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010);
+            bool4x4 r0 = bool4x4(false, false, true, true, true, true, false, true, false, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            int a1 = (1596056507);
+            int4x4 b1 = int4x4(1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, true, true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            int a2 = (1984930954);
+            int4x4 b2 = int4x4(743544838, 1473400608, 1300775973, 1351720916, 168788814, 670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            int a3 = (685700324);
+            int4x4 b3 = int4x4(697607066, 378454814, 1198070277, 1821642406, 1324129275, 905046836, 1897627028, 1715796299, 15666859, 1806453893, 1315963488, 545979816, 1486981760, 511543521, 1872978447, 303832107);
+            bool4x4 r3 = bool4x4(true, false, true, true, true, true, true, true, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_wide_wide()
+        {
+            int4x4 a0 = int4x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            int4x4 b0 = int4x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool4x4 r0 = bool4x4(true, true, false, true, false, true, false, false, true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x4 a1 = int4x4(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622, 1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            int4x4 b1 = int4x4(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265, 335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, true, true, true, true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x4 a2 = int4x4(31516321, 1786538920, 1854361210, 1730650972, 194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            int4x4 b2 = int4x4(1782348324, 550490783, 599992449, 550520692, 1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool4x4 r2 = bool4x4(false, true, true, true, false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x4 a3 = int4x4(475547465, 876276892, 916067531, 1712032702, 752041926, 899534759, 948020518, 1553126337, 1209858994, 1210234744, 1065677570, 2063434729, 1808415708, 1536857930, 1356745398, 1161445540);
+            int4x4 b3 = int4x4(594141080, 1888303265, 1023987839, 695072711, 164764812, 1404792693, 1068554108, 1615410626, 387184925, 1930375043, 1920744920, 1913267890, 12598306, 1697936155, 145255547, 1903607817);
+            bool4x4 r3 = bool4x4(false, false, false, true, true, false, false, false, true, false, false, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_wide_scalar()
+        {
+            int4x4 a0 = int4x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717);
+            int b0 = (438688675);
+            bool4x4 r0 = bool4x4(true, false, true, false, false, true, true, true, true, false, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int4x4 a1 = int4x4(1016617211, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419, 1058332184, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358);
+            int b1 = (2063134811);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int4x4 a2 = int4x4(614746280, 1683117650, 1451781409, 61102732, 1284938191, 1452639553, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269);
+            int b2 = (1000986708);
+            bool4x4 r2 = bool4x4(false, true, true, false, true, true, true, false, true, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int4x4 a3 = int4x4(1930086291, 2112194236, 1797322269, 1781660503, 1442606402, 208047803, 1193639690, 1939917219, 1146005869, 865123927, 913186094, 35693052, 1017084356, 91189073, 369398582, 2082818804);
+            int b3 = (108635332);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_scalar_wide()
+        {
+            int a0 = (2024896938);
+            int4x4 b0 = int4x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            int a1 = (1052151621);
+            int4x4 b1 = int4x4(1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588);
+            bool4x4 r1 = bool4x4(true, false, false, true, true, false, true, true, false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            int a2 = (2063431853);
+            int4x4 b2 = int4x4(2079035844, 849337819, 1769234051, 358948261, 267985383, 126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217);
+            bool4x4 r2 = bool4x4(false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            int a3 = (1480829811);
+            int4x4 b3 = int4x4(1903710461, 402220631, 266619022, 1724999252, 2113910076, 945951388, 1448605169, 1162548302, 1691586468, 996819204, 1151046248, 1924073034, 1910741238, 633631666, 307560646, 722552263);
+            bool4x4 r3 = bool4x4(false, true, true, false, false, true, true, true, false, true, true, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_equal_wide_wide()
+        {
+            int4x4 a0 = int4x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            int4x4 b0 = int4x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool4x4 r0 = bool4x4(false, true, false, true, true, false, false, true, true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x4 a1 = int4x4(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884, 912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            int4x4 b1 = int4x4(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017, 620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool4x4 r1 = bool4x4(true, false, true, false, true, false, true, false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x4 a2 = int4x4(269897278, 1062947703, 1743454202, 2048964070, 1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            int4x4 b2 = int4x4(648547686, 418431167, 1724009726, 401891826, 1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool4x4 r2 = bool4x4(true, false, false, false, true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x4 a3 = int4x4(442205781, 1050725689, 995151913, 926131462, 719271722, 1981390876, 659121091, 797556380, 1656192110, 66093862, 1964540799, 71894133, 1413886687, 1028466491, 1397158841, 1544483525);
+            int4x4 b3 = int4x4(1168998468, 1205894972, 1079707717, 1335643913, 1590790195, 155622033, 898990095, 1384002796, 1664888803, 1004528037, 402969524, 1299806519, 1194091234, 1673771542, 178191331, 98165007);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, false, true, true, true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_equal_wide_scalar()
+        {
+            int4x4 a0 = int4x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043);
+            int b0 = (1688048545);
+            bool4x4 r0 = bool4x4(false, true, true, true, true, false, true, true, true, false, true, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int4x4 a1 = int4x4(1617221948, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750, 1258115260, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606);
+            int b1 = (2017733017);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int4x4 a2 = int4x4(626254356, 1021674613, 127839058, 1974631244, 426908235, 1818566980, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266);
+            int b2 = (1162369122);
+            bool4x4 r2 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int4x4 a3 = int4x4(1483727269, 1823599046, 1379007149, 1836699751, 777126023, 1288116795, 834230828, 172303141, 577773919, 705141691, 191477430, 868528232, 499782260, 146328981, 1401289768, 858105804);
+            int b3 = (2045244870);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_less_equal_scalar_wide()
+        {
+            int a0 = (1777585);
+            int4x4 b0 = int4x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            int a1 = (1576473309);
+            int4x4 b1 = int4x4(861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850, 830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, true, false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            int a2 = (1556906486);
+            int4x4 b2 = int4x4(205552788, 620963188, 1156705971, 1121867260, 733876180, 1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, true, false, false, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            int a3 = (1987696011);
+            int4x4 b3 = int4x4(1079808067, 363499438, 1873483674, 2031411422, 1979820112, 1682214687, 1470726710, 1285823822, 758372610, 44568907, 1533310851, 14070795, 1758870243, 68371537, 1482970849, 1750868121);
+            bool4x4 r3 = bool4x4(false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_equal_wide_wide()
+        {
+            int4x4 a0 = int4x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            int4x4 b0 = int4x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool4x4 r0 = bool4x4(false, false, true, false, true, true, true, false, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x4 a1 = int4x4(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474, 605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            int4x4 b1 = int4x4(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253, 2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool4x4 r1 = bool4x4(false, false, false, true, false, true, false, true, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x4 a2 = int4x4(796452624, 1710612922, 1629927787, 1094198224, 584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            int4x4 b2 = int4x4(802468307, 1090745055, 1968071275, 1935027815, 2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool4x4 r2 = bool4x4(false, true, false, false, false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x4 a3 = int4x4(1030060516, 615638735, 1677201099, 325128466, 930989694, 165845388, 1887735446, 1905061476, 644732756, 1450709301, 811708233, 1120546613, 1966081819, 1710484814, 390900048, 1847748897);
+            int4x4 b3 = int4x4(222415803, 345913533, 920804419, 784455413, 1919795492, 2125545957, 957291149, 1547385242, 953814071, 685286053, 63764322, 1742849383, 1781391465, 64816935, 1543363698, 1439322689);
+            bool4x4 r3 = bool4x4(true, true, true, false, false, false, true, true, false, true, true, false, true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_equal_wide_scalar()
+        {
+            int4x4 a0 = int4x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917);
+            int b0 = (1470533736);
+            bool4x4 r0 = bool4x4(true, false, false, true, false, false, false, false, false, true, false, false, false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int4x4 a1 = int4x4(1646290021, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607, 1223010129, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027);
+            int b1 = (196833647);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int4x4 a2 = int4x4(1138747386, 917503963, 353608194, 1526792895, 192092521, 909358617, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700);
+            int b2 = (1491562090);
+            bool4x4 r2 = bool4x4(false, false, false, true, false, false, false, true, false, false, false, true, true, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int4x4 a3 = int4x4(702382564, 1013770865, 1420374964, 341399575, 2033070823, 672716789, 1809028740, 2070046852, 1254367930, 1206207650, 807585496, 1243142372, 350377587, 214724394, 216954982, 201992840);
+            int b3 = (2086058548);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_greater_equal_scalar_wide()
+        {
+            int a0 = (1525542481);
+            int4x4 b0 = int4x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, false, true, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            int a1 = (945321577);
+            int4x4 b1 = int4x4(173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727);
+            bool4x4 r1 = bool4x4(true, true, true, false, false, false, true, false, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            int a2 = (337378780);
+            int4x4 b2 = int4x4(273010835, 1898553615, 1111540136, 717385513, 474197678, 1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168);
+            bool4x4 r2 = bool4x4(true, false, false, false, false, false, false, false, true, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            int a3 = (1274079907);
+            int4x4 b3 = int4x4(1834102381, 22983902, 1733648920, 2089437749, 476445313, 1296111196, 422851096, 1857250030, 1382182918, 449792502, 1785823601, 668960891, 1067260705, 1973471752, 1403490846, 1510985557);
+            bool4x4 r3 = bool4x4(false, true, false, false, true, false, true, false, false, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_add_wide_wide()
+        {
+            int4x4 a0 = int4x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            int4x4 b0 = int4x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            int4x4 r0 = int4x4(-156987058, -1990545264, 798588178, 941373626, 587156660, -1136512864, 1721667438, -1850333135, -2009504361, 1101613923, -799189804, 1384643660, -147610603, 749502583, 623052937, -1181627673);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x4 a1 = int4x4(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366, 941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            int4x4 b1 = int4x4(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905, 2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            int4x4 r1 = int4x4(-2116725070, -1148541136, 1773819622, 1465624218, -1005576211, 1652367771, 1680948431, 1360647271, -1246101576, -1393575153, 1940611170, 1099044556, -1932199380, 1285092016, -1653104091, -537584005);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x4 a2 = int4x4(526120638, 423980484, 1867227242, 603782684, 728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            int4x4 b2 = int4x4(77965941, 1726775513, 1759186349, 2070333485, 1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            int4x4 r2 = int4x4(604086579, -2144211299, -668553705, -1620851127, -1833755501, 1450246522, -1850179797, 1669976746, -938217892, 1917402232, 1548618217, -1431586812, -823896228, 2013864506, 348877644, -2052539555);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x4 a3 = int4x4(1603943169, 858711604, 278076564, 983811310, 1503210133, 1265840052, 1220817560, 839507207, 142866678, 1356231306, 1432159402, 637785903, 1032109021, 2081298882, 331695947, 1983868469);
+            int4x4 b3 = int4x4(361542573, 900925442, 1077800500, 1330170201, 984058816, 207503339, 339145243, 1051497556, 1435620725, 2105629028, 1215478628, 393193121, 901424214, 189116452, 17408580, 466230809);
+            int4x4 r3 = int4x4(1965485742, 1759637046, 1355877064, -1980985785, -1807698347, 1473343391, 1559962803, 1891004763, 1578487403, -833106962, -1647329266, 1030979024, 1933533235, -2024551962, 349104527, -1844868018);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_add_wide_scalar()
+        {
+            int4x4 a0 = int4x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485);
+            int b0 = (2124409227);
+            int4x4 r0 = int4x4(-132339612, -2035634358, -1294868402, -831673606, -1172847141, -1830067198, -1102669940, -2100124768, -167536208, -534586098, -1010159783, -2085111867, -1102405103, -931170969, -672881181, -443080584);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int4x4 a1 = int4x4(1095438654, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260, 736972565, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263);
+            int b1 = (756559204);
+            int4x4 r1 = int4x4(1851997858, -1719689161, 1415482756, -1927889171, -1952652694, 1449402504, 1825152673, -1833631859, 1334341464, 1493531769, 1468453775, 1320816643, -1486671809, -1965570395, -1910401547, -1682707829);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int4x4 a2 = int4x4(656748782, 1917133199, 828322973, 2116810190, 2092767444, 973587865, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914);
+            int b2 = (272774516);
+            int4x4 r2 = int4x4(929523298, -2105059581, 1101097489, -1905382590, -1929425336, 1246362381, 1509705789, 777038965, 1067067090, 1790833197, 1877410840, 627647933, 958022413, 500555656, 593957033, 1483350430);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int4x4 a3 = int4x4(1340503111, 1979965576, 1988286575, 427699536, 538653829, 1589564058, 1954579845, 1781591877, 419928668, 1751001953, 355993558, 1653659509, 2098769225, 63134274, 1679875388, 377229586);
+            int b3 = (838567468);
+            int4x4 r3 = int4x4(-2115896717, -1476434252, -1468113253, 1266267004, 1377221297, -1866835770, -1501819983, -1674807951, 1258496136, -1705397875, 1194561026, -1802740319, -1357630603, 901701742, -1776524440, 1215797054);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_add_scalar_wide()
+        {
+            int a0 = (391092078);
+            int4x4 b0 = int4x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861);
+            int4x4 r0 = int4x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, -2122178146, 1387123903, 1948867027, 1170867018, 1502633380, 1174138523, 1521256022, 679371662, 1788775939);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            int a1 = (1636583489);
+            int4x4 b1 = int4x4(673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640);
+            int4x4 r1 = int4x4(-1985120468, -1189082933, 1651439454, -1541746808, -1169520507, -1057392921, 1827234790, -1350924039, -1738297968, -576153972, -665978233, -1444459349, 2142424941, -1676962645, -1170046108, -1544557167);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            int a2 = (1806146508);
+            int4x4 b2 = int4x4(1841791222, 206610851, 526971953, 1236359886, 1459523189, 965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031);
+            int4x4 r2 = int4x4(-647029566, 2012757359, -1961848835, -1252460902, -1029297599, -1523080157, 1888989307, -1190417587, -683011016, -509956597, -2073817402, -582516640, -1765950591, -1744571992, -811597229, 2109522539);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            int a3 = (1275565021);
+            int4x4 b3 = int4x4(1518386617, 233426699, 1128986758, 1421938726, 1178529217, 1397917053, 137663521, 975646083, 1968321168, 720648013, 1606974342, 567772614, 490190373, 576353787, 1438920888, 2145198309);
+            int4x4 r3 = int4x4(-1501015658, 1508991720, -1890415517, -1597463549, -1840873058, -1621485222, 1413228542, -2043756192, -1051081107, 1996213034, -1412427933, 1843337635, 1765755394, 1851918808, -1580481387, -874203966);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_sub_wide_wide()
+        {
+            int4x4 a0 = int4x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            int4x4 b0 = int4x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            int4x4 r0 = int4x4(20784306, -1030524174, -312569319, -2022211568, -1142336855, 690591734, 570660497, -136914747, 1234495882, -838948052, -732179165, -881462314, -50205903, -930193352, 120810088, 929308315);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x4 a1 = int4x4(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454, 425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            int4x4 b1 = int4x4(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855, 609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            int4x4 r1 = int4x4(-624402009, -165899077, -728396869, -162295434, 676719274, 647669761, 957134686, -776749401, -183740135, 972642792, -549594154, -1468159992, -730634354, 1218011798, 1846728662, -555907518);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x4 a2 = int4x4(1888446703, 1364654917, 265135366, 760501098, 741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            int4x4 b2 = int4x4(1224986479, 748933681, 88793450, 401362529, 1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            int4x4 r2 = int4x4(663460224, 615721236, 176341916, 359138569, -345917539, 1650323877, 979082147, 182559134, -136395064, 1442113917, 8339009, 1379854326, -592461473, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x4 a3 = int4x4(1541023885, 1644155041, 1885220021, 956814489, 1996571272, 313052858, 1686326525, 1591026645, 404689020, 832057610, 817031413, 1191376096, 1515565534, 178300672, 365767493, 1238101305);
+            int4x4 b3 = int4x4(120176164, 834539498, 1843750420, 337055138, 1625604945, 41302648, 1719986021, 2028592747, 609982501, 95087400, 1244763386, 1175550114, 887604651, 1249524531, 155418749, 1934403979);
+            int4x4 r3 = int4x4(1420847721, 809615543, 41469601, 619759351, 370966327, 271750210, -33659496, -437566102, -205293481, 736970210, -427731973, 15825982, 627960883, -1071223859, 210348744, -696302674);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_sub_wide_scalar()
+        {
+            int4x4 a0 = int4x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189);
+            int b0 = (462232403);
+            int4x4 r0 = int4x4(714137155, 1472288792, -152780253, 955401671, -353321686, 844124311, 1040079931, 989562412, -181058203, -374701563, 1451492028, 1579360933, 95007587, 656819045, 1128144329, 356857786);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int4x4 a1 = int4x4(816382635, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794, 819644478, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758);
+            int b1 = (815920639);
+            int4x4 r1 = int4x4(461996, 1013112478, 976881293, 297519910, 603017337, 461336550, 1276858759, -173683897, 789330155, 3723839, 652082380, -687617453, -262426382, 201206332, 1183824143, 1201352119);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int4x4 a2 = int4x4(1817991764, 676974855, 1638032613, 949761204, 1835969317, 919015590, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965);
+            int b2 = (1280985500);
+            int4x4 r2 = int4x4(537006264, -604010645, 357047113, -331224296, 554983817, -361969910, -304038190, 23261106, 175794708, 273037212, -511181135, 776846187, -522848921, -610552245, -677754089, 392283465);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int4x4 a3 = int4x4(941598524, 1394256067, 1267352835, 62929009, 1190778074, 657264006, 364156399, 775397332, 651143570, 486712236, 34309315, 1323491629, 1875163590, 1217887516, 2061463296, 24320578);
+            int b3 = (2122131631);
+            int4x4 r3 = int4x4(-1180533107, -727875564, -854778796, -2059202622, -931353557, -1464867625, -1757975232, -1346734299, -1470988061, -1635419395, -2087822316, -798640002, -246968041, -904244115, -60668335, -2097811053);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_sub_scalar_wide()
+        {
+            int a0 = (1691534405);
+            int4x4 b0 = int4x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719);
+            int4x4 r0 = int4x4(-330859405, 78845890, 1194844692, 804496819, -406096559, 1316599867, 752498923, 756292128, -97766016, 1426821512, 459678338, -126578343, 263098296, 432788945, 614154009, 360811686);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            int a1 = (518111829);
+            int4x4 b1 = int4x4(967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530);
+            int4x4 r1 = int4x4(-449016700, 173445575, -564156089, -389754867, -1298773294, 57771261, -444042669, -39001632, -1183104880, -1461986948, -211948723, -926285998, -335458727, 379275397, -495078599, -199977701);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            int a2 = (506757390);
+            int4x4 b2 = int4x4(1216448041, 936312747, 1997286455, 1969982026, 902880656, 1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072);
+            int4x4 r2 = int4x4(-709690651, -429555357, -1490529065, -1463224636, -396123266, -654463307, -935707335, -116203375, -224211519, -108066451, -1383021630, -411564962, 372827470, 293634282, -1328693070, -14310682);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            int a3 = (2066839749);
+            int4x4 b3 = int4x4(1982717309, 1580139939, 136826185, 783667709, 205508687, 1152347947, 1682018862, 329924125, 396414255, 542319408, 208974930, 1638328097, 935729865, 125876461, 218665639, 1100023218);
+            int4x4 r3 = int4x4(84122440, 486699810, 1930013564, 1283172040, 1861331062, 914491802, 384820887, 1736915624, 1670425494, 1524520341, 1857864819, 428511652, 1131109884, 1940963288, 1848174110, 966816531);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mul_wide_wide()
+        {
+            int4x4 a0 = int4x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            int4x4 b0 = int4x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            int4x4 r0 = int4x4(-632811769, 1402281434, 332447596, -1932977561, -1670918566, 1455036648, 2128344329, -594088068, -1654168033, 2093463192, -1207506618, -1133560830, 990589280, -938173952, -1341723466, 1156600361);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x4 a1 = int4x4(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234, 899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            int4x4 b1 = int4x4(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952, 675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            int4x4 r1 = int4x4(649177976, 678952165, 1063621177, -1611682740, -2142428392, -573253741, -1652113678, 1626072720, 1891467339, 335415735, 1128927428, -1656253776, -1433851638, 479369680, -366628060, -250163942);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x4 a2 = int4x4(200879709, 857149632, 962693646, 988118613, 892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            int4x4 b2 = int4x4(1695925670, 1788874462, 534570710, 1110638325, 142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            int4x4 r2 = int4x4(48406862, -1997863296, -275121228, -1483457191, 293009766, -617864326, 1179445736, -481780132, -1586128904, 1397450915, 487571412, -405680754, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x4 a3 = int4x4(1867348319, 464239430, 1513968722, 1879508953, 1835178747, 106255610, 791954119, 1098780631, 1336308698, 613897216, 1826550194, 1100684236, 67588307, 1388845400, 23402614, 2092286485);
+            int4x4 b3 = int4x4(1809758608, 288286688, 726755419, 364868101, 655080356, 266071904, 385013390, 186015668, 758488066, 1918847075, 1784720030, 1012303363, 135157062, 1204101671, 2062532388, 1665984668);
+            int4x4 r3 = int4x4(-1918112656, 2027161408, 1912621350, -108476099, 2728396, 1647526848, 418210914, 1845357612, 1544011700, -500859904, -1797693476, 468065124, -1956632398, 412191848, -1314817384, 1944145100);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mul_wide_scalar()
+        {
+            int4x4 a0 = int4x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657);
+            int b0 = (1476837906);
+            int4x4 r0 = int4x4(-1313177922, 1326807828, -2138555518, -276153754, -65548794, -1318584182, -1839224530, -1720506518, 1736252960, -1699123674, -1534863838, -1853528010, -1668168436, -1977548968, 1423071262, 2117820994);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int4x4 a1 = int4x4(391009467, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703, 1613845584, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062);
+            int b1 = (1186856590);
+            int4x4 r1 = int4x4(1435732410, 218605196, 1896985092, -1774863802, -125434376, -750863902, -1084645148, 2141566616, -1063702942, 1813259360, -1722207966, -1862268928, 714733494, 209765036, 1993704396, 95853188);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int4x4 a2 = int4x4(987919119, 1325430351, 948943118, 1743760648, 227492421, 217698851, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790);
+            int b2 = (1659987051);
+            int4x4 r2 = int4x4(548860741, -775467259, 1518981338, 88896088, 1840817879, 997425313, -1094396229, 1277937072, 1861085478, -682201364, 98332333, -750570710, -1089412702, -1543745504, 438848394, -1975359678);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int4x4 a3 = int4x4(396984449, 352046491, 1513331645, 1155106274, 138823406, 923862962, 131310587, 938688263, 631817444, 1890216972, 2143914807, 30238797, 5224899, 1350553408, 2127554014, 1666837332);
+            int b3 = (474729765);
+            int4x4 r3 = int4x4(-382607451, -596453785, -1450517679, 349983658, 1219417702, 1371907770, 443527751, 447592195, 903547124, -1196738116, -1447482893, -1178289119, -1553465297, -1288752064, 1864957718, 2131576612);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mul_scalar_wide()
+        {
+            int a0 = (99541948);
+            int4x4 b0 = int4x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488);
+            int4x4 r0 = int4x4(-950398648, -102049016, 1260585960, 1158730452, -1606056, -466153048, 2108402516, 1966690328, 1623617844, -1691554240, -830512240, -1283699420, -628079900, 1294445652, 1610098852, -691055360);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            int a1 = (459880225);
+            int4x4 b1 = int4x4(994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281);
+            int4x4 r1 = int4x4(1378091637, 738687535, -826518076, -345210155, 316193853, 2121309665, -222642187, 1750778551, -1730990718, 133205964, 1859727169, 388250044, -611993629, -1492821565, -516072495, 1074594065);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            int a2 = (2138825098);
+            int4x4 b2 = int4x4(1273008873, 1788343477, 1994364082, 597340263, 2022856151, 1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370);
+            int4x4 r2 = int4x4(1965095578, 1643380370, 1438423540, 15376006, -2086585114, 1819612578, -1355210390, -1011516056, -1566641956, -1061125150, -127290192, 1377278202, -2072591672, -368393398, 572695294, -1561208268);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            int a3 = (890235481);
+            int4x4 b3 = int4x4(1880345584, 1882904983, 267128787, 1569254022, 1779318576, 1645728412, 819681361, 666095044, 308815496, 1829465065, 751656026, 1207837213, 1073832960, 169923853, 808603307, 363334486);
+            int4x4 r3 = int4x4(-1302641040, -768431233, -337289637, 651297942, -2004494416, -2081501124, 1824177705, -904679132, 56997192, -381518335, 1427464010, 1396399637, 1642316800, -1259670651, -1066752141, -1714254618);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_div_wide_wide()
+        {
+            int4x4 a0 = int4x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            int4x4 b0 = int4x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            int4x4 r0 = int4x4(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x4 a1 = int4x4(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343, 1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            int4x4 b1 = int4x4(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844, 616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            int4x4 r1 = int4x4(1, 39, 0, 1, 1, 1, 1, 0, 2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x4 a2 = int4x4(850951883, 1942618200, 1088675276, 1648515976, 991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            int4x4 b2 = int4x4(1535651093, 932740870, 1078416711, 725172174, 554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            int4x4 r2 = int4x4(0, 2, 1, 2, 1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x4 a3 = int4x4(308887330, 7606985, 1626977876, 1895907215, 1115090617, 1043375525, 168865453, 1056135390, 1080260308, 780473703, 1917865869, 1741288184, 497930923, 668217348, 1678197677, 1075043333);
+            int4x4 b3 = int4x4(1549803350, 364926102, 1386892120, 656711993, 91320418, 1458063222, 1529573616, 722321620, 757577900, 1175347146, 1933900601, 1063907544, 97856937, 972434416, 1920248258, 261846189);
+            int4x4 r3 = int4x4(0, 0, 1, 2, 12, 0, 0, 1, 1, 0, 0, 1, 5, 0, 0, 4);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_div_wide_scalar()
+        {
+            int4x4 a0 = int4x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029);
+            int b0 = (947861580);
+            int4x4 r0 = int4x4(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1, 2, 2, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int4x4 a1 = int4x4(1646044372, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156);
+            int b1 = (1447236569);
+            int4x4 r1 = int4x4(1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int4x4 a2 = int4x4(1725332114, 1383839785, 2136282541, 159847918, 1515555001, 614923813, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647);
+            int b2 = (1949103348);
+            int4x4 r2 = int4x4(0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int4x4 a3 = int4x4(1222061694, 1966139194, 1303421248, 1811535294, 240471953, 2116688995, 1035856383, 2022133852, 2147186889, 152458544, 148729436, 318083619, 980911803, 817677917, 398058007, 747046501);
+            int b3 = (579280546);
+            int4x4 r3 = int4x4(2, 3, 2, 3, 0, 3, 1, 3, 3, 0, 0, 0, 1, 1, 0, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_div_scalar_wide()
+        {
+            int a0 = (1161272038);
+            int4x4 b0 = int4x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097);
+            int4x4 r0 = int4x4(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25, 1, 2, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            int a1 = (1818363859);
+            int4x4 b1 = int4x4(1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309);
+            int4x4 r1 = int4x4(1, 6, 37, 1, 1, 1, 0, 2, 1, 5, 13, 1, 4, 1, 7, 1);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            int a2 = (2114509003);
+            int4x4 b2 = int4x4(1266146708, 45105265, 2092444751, 407744534, 126616016, 1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719);
+            int4x4 r2 = int4x4(1, 46, 1, 5, 16, 1, 4, 5, 1, 2, 1, 11, 3, 2, 3, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            int a3 = (638134699);
+            int4x4 b3 = int4x4(297472499, 1196796276, 815483831, 1511819303, 906952957, 613050421, 60483276, 883893666, 1481847510, 1065163200, 1641516292, 1980940753, 1862370918, 2048575092, 396483978, 610486041);
+            int4x4 r3 = int4x4(2, 0, 0, 0, 0, 1, 10, 0, 0, 0, 0, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mod_wide_wide()
+        {
+            int4x4 a0 = int4x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            int4x4 b0 = int4x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            int4x4 r0 = int4x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x4 a1 = int4x4(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189, 1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            int4x4 b1 = int4x4(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748, 798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            int4x4 r1 = int4x4(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189, 604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x4 a2 = int4x4(1090018756, 1573062648, 1100694500, 863521889, 1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            int4x4 b2 = int4x4(1350943898, 696511738, 1182727748, 1843845940, 244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            int4x4 r2 = int4x4(1090018756, 180039172, 1100694500, 863521889, 166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x4 a3 = int4x4(1759996408, 1386598712, 251325313, 122732248, 2082099427, 1080998866, 686623511, 693281682, 302610170, 1380134301, 1661197566, 481331690, 1193753109, 166363462, 588323181, 594997700);
+            int4x4 b3 = int4x4(951215450, 195024879, 2079991098, 220236959, 294448639, 1396793894, 141031566, 960537512, 719675899, 928202057, 275228822, 1510254672, 1481505055, 1373357922, 1940197321, 286975465);
+            int4x4 r3 = int4x4(808780958, 21424559, 251325313, 122732248, 20958954, 1080998866, 122497247, 693281682, 302610170, 451932244, 9824634, 481331690, 1193753109, 166363462, 588323181, 21046770);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mod_wide_scalar()
+        {
+            int4x4 a0 = int4x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743);
+            int b0 = (883951171);
+            int4x4 r0 = int4x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764, 712321026, 172564850, 656117274, 201946572);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int4x4 a1 = int4x4(1607489717, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313, 1778384846, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470);
+            int b1 = (165478511);
+            int4x4 r1 = int4x4(118183118, 151411183, 88315444, 113523802, 100798728, 92063740, 157552667, 102078780, 46544291, 123599736, 57662177, 150269373, 160931436, 153365271, 104447121, 3383426);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int4x4 a2 = int4x4(1568090825, 435886407, 453990946, 1731665372, 586777590, 1475597526, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411);
+            int b2 = (2050982942);
+            int4x4 r2 = int4x4(1568090825, 435886407, 453990946, 1731665372, 586777590, 1475597526, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 79363616, 666621411);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int4x4 a3 = int4x4(1524342239, 1547690684, 857915601, 709453751, 2103243535, 2124726669, 1410239986, 1761316053, 442891932, 388101009, 1059801526, 651827482, 1890268914, 910020375, 58051452, 293939465);
+            int b3 = (1490592900);
+            int4x4 r3 = int4x4(33749339, 57097784, 857915601, 709453751, 612650635, 634133769, 1410239986, 270723153, 442891932, 388101009, 1059801526, 651827482, 399676014, 910020375, 58051452, 293939465);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_mod_scalar_wide()
+        {
+            int a0 = (242383789);
+            int4x4 b0 = int4x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131);
+            int4x4 r0 = int4x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            int a1 = (1859742342);
+            int4x4 b1 = int4x4(797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388);
+            int4x4 r1 = int4x4(265372968, 215964658, 776549345, 179512370, 1859742342, 14262450, 374167220, 1418334, 1859742342, 49383671, 399566104, 414796203, 553950305, 748913331, 114295180, 24421074);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            int a2 = (1477846418);
+            int4x4 b2 = int4x4(511428733, 1642227542, 1962310765, 207128894, 1342085447, 448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751);
+            int4x4 r2 = int4x4(454988952, 1477846418, 1477846418, 27944160, 135760971, 132762560, 139176342, 66914916, 724757645, 331502408, 102145698, 403366277, 1477846418, 1477846418, 1477846418, 379404667);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            int a3 = (1648646354);
+            int4x4 b3 = int4x4(1730303822, 859376331, 889118656, 1549752450, 992618236, 941290327, 1766644910, 435947831, 1937100534, 1342633977, 1176317048, 950230773, 1135152183, 384466155, 600022, 363833845);
+            int4x4 r3 = int4x4(1648646354, 789270023, 759527698, 98893904, 656028118, 707356027, 1648646354, 340802861, 1648646354, 306012377, 472329306, 698415581, 513494171, 110781734, 385920, 193310974);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_plus()
+        {
+            int4x4 a0 = int4x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926);
+            int4x4 r0 = int4x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926);
+            TestUtils.AreEqual(+a0, r0);
+
+            int4x4 a1 = int4x4(2049663954, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393);
+            int4x4 r1 = int4x4(2049663954, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393);
+            TestUtils.AreEqual(+a1, r1);
+
+            int4x4 a2 = int4x4(829347661, 381670450, 277507230, 361395485, 1012749225, 1204186973, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986);
+            int4x4 r2 = int4x4(829347661, 381670450, 277507230, 361395485, 1012749225, 1204186973, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986);
+            TestUtils.AreEqual(+a2, r2);
+
+            int4x4 a3 = int4x4(1257555634, 578585280, 1087392044, 2084329354, 300198860, 1247120404, 1325809345, 1057524082, 1426592020, 167918579, 1552986194, 813448514, 2048383407, 647476365, 13335381, 1985958169);
+            int4x4 r3 = int4x4(1257555634, 578585280, 1087392044, 2084329354, 300198860, 1247120404, 1325809345, 1057524082, 1426592020, 167918579, 1552986194, 813448514, 2048383407, 647476365, 13335381, 1985958169);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_neg()
+        {
+            int4x4 a0 = int4x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242);
+            int4x4 r0 = int4x4(-1955022112, -662160019, -370300775, -2141283773, -1004505619, -28153593, -33894270, -505708349, -1115028238, -1636274969, -694995093, -1542206286, -213087293, -243937487, -341522275, -841085242);
+            TestUtils.AreEqual(-a0, r0);
+
+            int4x4 a1 = int4x4(574159094, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284);
+            int4x4 r1 = int4x4(-574159094, -2057919693, -1175014732, -1259809073, -1212465326, -1190569920, -2047955772, -2120729864, -1440774928, -1485596454, -431666091, -1387601718, -1745651998, -319115626, -1119959806, -739132284);
+            TestUtils.AreEqual(-a1, r1);
+
+            int4x4 a2 = int4x4(1954173314, 1836511050, 1662806453, 506144868, 650922971, 1755382554, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551);
+            int4x4 r2 = int4x4(-1954173314, -1836511050, -1662806453, -506144868, -650922971, -1755382554, -1273997249, -1474445187, -1853826947, -1695573773, -729452512, -345069360, -575867536, -594119038, -1201840609, -1342872551);
+            TestUtils.AreEqual(-a2, r2);
+
+            int4x4 a3 = int4x4(1768435578, 23008237, 1410502890, 695213039, 1342131852, 1619073746, 469828650, 20553909, 1711214338, 690040786, 1749711826, 1265590278, 1516859887, 1317159343, 1722518934, 803074002);
+            int4x4 r3 = int4x4(-1768435578, -23008237, -1410502890, -695213039, -1342131852, -1619073746, -469828650, -20553909, -1711214338, -690040786, -1749711826, -1265590278, -1516859887, -1317159343, -1722518934, -803074002);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_prefix_inc()
+        {
+            int4x4 a0 = int4x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402);
+            int4x4 r0 = int4x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403);
+            TestUtils.AreEqual(++a0, r0);
+
+            int4x4 a1 = int4x4(1786514683, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865, 519296647, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661);
+            int4x4 r1 = int4x4(1786514684, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866, 519296648, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662);
+            TestUtils.AreEqual(++a1, r1);
+
+            int4x4 a2 = int4x4(65514038, 1321109497, 1366348660, 1777734111, 1414867743, 536776365, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802);
+            int4x4 r2 = int4x4(65514039, 1321109498, 1366348661, 1777734112, 1414867744, 536776366, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803);
+            TestUtils.AreEqual(++a2, r2);
+
+            int4x4 a3 = int4x4(413165245, 1206806909, 2069192976, 1613073974, 1342402025, 330167396, 665917965, 799320426, 2054286971, 2074397725, 113129500, 721162954, 2136093351, 173315234, 2006582934, 265026274);
+            int4x4 r3 = int4x4(413165246, 1206806910, 2069192977, 1613073975, 1342402026, 330167397, 665917966, 799320427, 2054286972, 2074397726, 113129501, 721162955, 2136093352, 173315235, 2006582935, 265026275);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_postfix_inc()
+        {
+            int4x4 a0 = int4x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778);
+            int4x4 r0 = int4x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778);
+            TestUtils.AreEqual(a0++, r0);
+
+            int4x4 a1 = int4x4(717006530, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403);
+            int4x4 r1 = int4x4(717006530, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403);
+            TestUtils.AreEqual(a1++, r1);
+
+            int4x4 a2 = int4x4(1919960927, 2010345998, 1047836590, 586887730, 1209169651, 1051531454, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320);
+            int4x4 r2 = int4x4(1919960927, 2010345998, 1047836590, 586887730, 1209169651, 1051531454, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320);
+            TestUtils.AreEqual(a2++, r2);
+
+            int4x4 a3 = int4x4(1995020676, 183815949, 1207670946, 1620827725, 1809811548, 1643094131, 280506984, 382615051, 650280741, 560631765, 1840722506, 63273626, 1294940978, 724310154, 1901579798, 697321264);
+            int4x4 r3 = int4x4(1995020676, 183815949, 1207670946, 1620827725, 1809811548, 1643094131, 280506984, 382615051, 650280741, 560631765, 1840722506, 63273626, 1294940978, 724310154, 1901579798, 697321264);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_prefix_dec()
+        {
+            int4x4 a0 = int4x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392);
+            int4x4 r0 = int4x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391);
+            TestUtils.AreEqual(--a0, r0);
+
+            int4x4 a1 = int4x4(1310293956, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829, 1454322707, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100);
+            int4x4 r1 = int4x4(1310293955, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828, 1454322706, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099);
+            TestUtils.AreEqual(--a1, r1);
+
+            int4x4 a2 = int4x4(157482354, 1797304434, 1083672612, 929765380, 2083512379, 2045544045, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317);
+            int4x4 r2 = int4x4(157482353, 1797304433, 1083672611, 929765379, 2083512378, 2045544044, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316);
+            TestUtils.AreEqual(--a2, r2);
+
+            int4x4 a3 = int4x4(767990877, 366067423, 99249400, 1549382038, 1105868582, 1977762759, 1646465385, 1067223071, 1774498387, 1128527977, 1104488553, 1575600100, 1141283662, 1678956750, 449874904, 748975258);
+            int4x4 r3 = int4x4(767990876, 366067422, 99249399, 1549382037, 1105868581, 1977762758, 1646465384, 1067223070, 1774498386, 1128527976, 1104488552, 1575600099, 1141283661, 1678956749, 449874903, 748975257);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_postfix_dec()
+        {
+            int4x4 a0 = int4x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868);
+            int4x4 r0 = int4x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868);
+            TestUtils.AreEqual(a0--, r0);
+
+            int4x4 a1 = int4x4(1867810045, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911);
+            int4x4 r1 = int4x4(1867810045, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911);
+            TestUtils.AreEqual(a1--, r1);
+
+            int4x4 a2 = int4x4(416440036, 1444496274, 296146626, 1209855130, 2016700604, 838640502, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298);
+            int4x4 r2 = int4x4(416440036, 1444496274, 296146626, 1209855130, 2016700604, 838640502, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298);
+            TestUtils.AreEqual(a2--, r2);
+
+            int4x4 a3 = int4x4(569144612, 509007463, 860240975, 41334109, 10321636, 1940079495, 43143738, 1044950720, 63756334, 1595004937, 699747920, 348534360, 509361827, 1352179420, 271823835, 1889179126);
+            int4x4 r3 = int4x4(569144612, 509007463, 860240975, 41334109, 10321636, 1940079495, 43143738, 1044950720, 63756334, 1595004937, 699747920, 348534360, 509361827, 1352179420, 271823835, 1889179126);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_and_wide_wide()
+        {
+            int4x4 a0 = int4x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            int4x4 b0 = int4x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            int4x4 r0 = int4x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x4 a1 = int4x4(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372, 181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            int4x4 b1 = int4x4(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586, 1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            int4x4 r1 = int4x4(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976, 177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x4 a2 = int4x4(1804502415, 1733695477, 1110712857, 113012430, 1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            int4x4 b2 = int4x4(843085933, 1045118223, 41867329, 1397669260, 1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            int4x4 r2 = int4x4(570425357, 641864965, 36962305, 34352268, 706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x4 a3 = int4x4(17366276, 1245846423, 1075177576, 1023499729, 1742176891, 1288325524, 2092131182, 1444013434, 210707066, 627341079, 155789028, 411695477, 2144207930, 1007799200, 382737478, 85407483);
+            int4x4 b3 = int4x4(267066435, 781393024, 1444337796, 139669978, 880161801, 1604286495, 839016626, 1986058500, 1905400692, 1670633815, 651063094, 967343492, 336245810, 914791376, 1696073831, 2103810347);
+            int4x4 r3 = int4x4(17308672, 167909504, 1075103744, 134287824, 609615881, 1284130836, 805462050, 1442889984, 8520304, 553668887, 4728356, 411597060, 336200754, 872450944, 68159558, 84217899);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_and_wide_scalar()
+        {
+            int4x4 a0 = int4x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472);
+            int b0 = (93423598);
+            int4x4 r0 = int4x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672, 1148422, 8389408, 83887462, 8488072);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int4x4 a1 = int4x4(861733033, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926, 1817145060, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772);
+            int b1 = (1408932942);
+            int4x4 r1 = int4x4(324534280, 286268488, 1366298692, 1102615626, 322044930, 1397755908, 6985796, 1137737800, 328371278, 1078594628, 1399326724, 1078989902, 281676870, 34212932, 1093304384, 9081924);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int4x4 a2 = int4x4(872875431, 708719245, 1764446048, 1527981061, 398141788, 156911041, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172);
+            int b2 = (1143080525);
+            int4x4 r2 = int4x4(67240965, 2228749, 1075971648, 1073873925, 69337164, 132161, 1537, 1140850701, 2098701, 69337665, 1140852237, 1073743369, 2229257, 1075970572, 2229320, 69207556);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int4x4 a3 = int4x4(1826788967, 3292432, 225233484, 1488146706, 1918853562, 1038188796, 1833784555, 252534533, 942504184, 840550591, 475152200, 1566941712, 546609146, 1803072768, 1125028552, 104252148);
+            int b3 = (150752148);
+            int4x4 r3 = int4x4(148898308, 3148048, 141314564, 145768720, 6046096, 148897940, 139214976, 135023364, 137119888, 1591444, 139463424, 140771856, 9700240, 142082304, 787072, 3424916);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_and_scalar_wide()
+        {
+            int a0 = (1144543590);
+            int4x4 b0 = int4x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291);
+            int4x4 r0 = int4x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300, 1075314980, 1076910436, 68698370, 6434);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            int a1 = (1085233038);
+            int4x4 b1 = int4x4(1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851);
+            int4x4 r1 = int4x4(1073939080, 2299648, 1082868362, 1082278790, 741382, 1082283648, 1082720778, 1082675206, 1076826496, 1074615948, 2245132, 1076646798, 1074419596, 1084490250, 8456066, 1076364674);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            int a2 = (372814411);
+            int4x4 b2 = int4x4(1623486506, 211665304, 1668985777, 348112007, 1808619374, 1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681);
+            int4x4 r2 = int4x4(12298, 68714504, 37270017, 339247107, 34083402, 304099905, 36212744, 337683019, 1048587, 338698304, 304128072, 369659979, 34643976, 372814339, 70791754, 35659841);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            int a3 = (1980296380);
+            int4x4 b3 = int4x4(1295368015, 859181113, 1741688223, 1249250718, 363989837, 939740255, 1668271386, 121498186, 1765635287, 1637255201, 1157123404, 216326016, 1525016040, 1131192672, 433812479, 797544392);
+            int4x4 r3 = int4x4(1140894732, 838860856, 1711279260, 1107299484, 335546380, 805325852, 1644743704, 101246984, 1611162772, 1610647584, 1141394444, 67161216, 1375790248, 1107861536, 268984508, 638094472);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_or_wide_wide()
+        {
+            int4x4 a0 = int4x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            int4x4 b0 = int4x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            int4x4 r0 = int4x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x4 a1 = int4x4(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074, 543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            int4x4 b1 = int4x4(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841, 108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            int4x4 r1 = int4x4(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171, 645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x4 a2 = int4x4(203868172, 32846030, 1057901177, 1537975433, 470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            int4x4 b2 = int4x4(2036352209, 1554561114, 1332339254, 480739851, 1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            int4x4 r2 = int4x4(2103889117, 1576909022, 2138040959, 1605346955, 1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x4 a3 = int4x4(237797826, 356229491, 1054697631, 2025966311, 718324935, 1223426852, 2042482036, 683169667, 1994321453, 240702936, 828468284, 1009506608, 708733945, 449892073, 1530051697, 654498852);
+            int4x4 b3 = int4x4(92416160, 446752586, 1307950607, 1358449730, 181367548, 432421751, 695223657, 56384197, 1119601678, 460615696, 463588364, 780415466, 1378457042, 1259569239, 1887579973, 358353719);
+            int4x4 r3 = int4x4(263104994, 532408187, 2147352223, 2029637351, 719320831, 1508785015, 2046676349, 737959879, 1996484143, 528283096, 1004661820, 1051720186, 2051014651, 1540607743, 2075311989, 928964407);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_or_wide_scalar()
+        {
+            int4x4 a0 = int4x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655);
+            int b0 = (1666102508);
+            int4x4 r0 = int4x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148, 2003812348, 1733293807, 1875836414, 2012132863);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int4x4 a1 = int4x4(46921989, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359, 1511253082, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015);
+            int b1 = (1980838747);
+            int4x4 r1 = int4x4(1994128223, 1995567963, 2010461179, 1991325695, 1997911899, 1991868383, 2131982331, 2122054655, 2124133343, 2115237723, 2144728923, 1981677563, 2136438655, 1993456507, 2138829791, 2130181087);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int4x4 a2 = int4x4(539526284, 1815369493, 529427586, 358352200, 1353013374, 1349149982, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643);
+            int b2 = (310877895);
+            int4x4 r2 = int4x4(850370255, 2125979607, 529530567, 400531407, 1386733311, 1391460319, 1927257823, 1404034799, 935313103, 518496247, 534241023, 451395303, 1928855535, 1452277503, 2012217327, 1452269263);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int4x4 a3 = int4x4(142082352, 1052987078, 1551897284, 647667876, 272240018, 728496025, 1212085507, 1717689835, 478474157, 1784582014, 1420783529, 671512087, 1240546077, 215180285, 1874077134, 288085841);
+            int b3 = (1760023655);
+            int4x4 r3 = int4x4(1761596791, 2129125095, 2095568615, 1862268135, 2030034423, 1810888703, 1761604967, 1860689391, 2095579119, 1795153791, 2096103407, 1760032375, 1777860479, 1828190207, 1878521327, 2045761399);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_or_scalar_wide()
+        {
+            int a0 = (1213433101);
+            int4x4 b0 = int4x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352);
+            int4x4 r0 = int4x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813, 2138308077, 1836824463, 1492630911, 1291306269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            int a1 = (424663473);
+            int4x4 b1 = int4x4(447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560);
+            int4x4 r1 = int4x4(469760441, 527432119, 2102393277, 461364733, 1540357117, 2038431217, 1609563133, 1608506353, 1508891639, 433060337, 2069888509, 1006631935, 1064296439, 2079326201, 1501560311, 964689913);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            int a2 = (990961386);
+            int4x4 b2 = int4x4(547309556, 1307122961, 263229121, 1518227598, 1098359242, 997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616);
+            int4x4 r2 = int4x4(1000333310, 2147082235, 1068556011, 2071912174, 2071461866, 997981930, 2065628926, 997326575, 1060233210, 2064900095, 2136670190, 2073878254, 1004142575, 997850858, 2075778799, 2144722938);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            int a3 = (1326199854);
+            int4x4 b3 = int4x4(1949398395, 2027606165, 1750615303, 908181664, 2105810564, 2009616838, 1492018691, 1325195313, 1365101592, 276155673, 1378507257, 1526287781, 322486040, 1550813488, 326334540, 2015237736);
+            int4x4 r3 = int4x4(2134734207, 2145318079, 1868330287, 2133718190, 2139897518, 2144105966, 1609463343, 1341977663, 1599994942, 1602092351, 1596882431, 1610448303, 1597816638, 1601158462, 1602190446, 2132686446);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_xor_wide_wide()
+        {
+            int4x4 a0 = int4x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            int4x4 b0 = int4x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            int4x4 r0 = int4x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x4 a1 = int4x4(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405, 1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            int4x4 b1 = int4x4(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483, 1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            int4x4 r1 = int4x4(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070, 981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x4 a2 = int4x4(32554542, 1915830925, 2001025156, 2012451132, 1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            int4x4 b2 = int4x4(325882121, 45335181, 1859278043, 1002624300, 1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            int4x4 r2 = int4x4(312225575, 1887600640, 429354079, 1278297104, 632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x4 a3 = int4x4(1730482516, 1488638921, 801348246, 1768559974, 1475767978, 1617893197, 689768843, 640586983, 426041408, 1811169716, 1563089576, 1411870628, 1004729442, 1173825171, 344960599, 633357624);
+            int4x4 b3 = int4x4(1356120192, 933877640, 2003767224, 113246892, 1236821680, 256717233, 1832711379, 238792988, 691507914, 1132023339, 1571029002, 227661589, 1609435614, 1581653714, 1384954643, 1432072515);
+            int4x4 r3 = int4x4(938594772, 1863517249, 1487705390, 1873418186, 508430362, 1864509180, 1143078232, 672474619, 810775178, 680333215, 9362082, 1505147057, 1678572988, 464599105, 1174607172, 1889268859);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_xor_wide_scalar()
+        {
+            int4x4 a0 = int4x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046);
+            int b0 = (493665894);
+            int4x4 r0 = int4x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053, 437376926, 1392927932, 2054402363, 463180344);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int4x4 a1 = int4x4(375757978, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736, 447453839, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973);
+            int b1 = (491079274);
+            int4x4 r1 = int4x4(186702576, 371762244, 375527487, 618745463, 1031986773, 1000908074, 491343762, 1164914022, 2036840370, 133094629, 677146516, 205099286, 36780645, 47041514, 1327792696, 1520547255);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int4x4 a2 = int4x4(1059509471, 64097148, 1814786305, 716239, 476052372, 92561487, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185);
+            int b2 = (744733291);
+            int4x4 r2 = int4x4(323317428, 800174359, 1078512490, 745101220, 809255423, 703060516, 1456372985, 773205017, 1645813588, 1368542166, 589723701, 717567903, 1805007853, 1363747113, 1583742507, 528804098);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int4x4 a3 = int4x4(1771744425, 1026064492, 275465401, 1157615659, 2091197990, 1671757076, 574090633, 458210617, 1604017559, 1913893498, 1791703422, 2143390933, 777506800, 1972227371, 2073971655, 61542294);
+            int b3 = (75727457);
+            int4x4 r3 = int4x4(1830366920, 967508493, 350799576, 1081889354, 2015798343, 1730641781, 649359336, 533479256, 1528356854, 1989160987, 1850260255, 2067926708, 718556561, 1896763210, 2132658598, 120098295);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_xor_scalar_wide()
+        {
+            int a0 = (1288453276);
+            int4x4 b0 = int4x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492);
+            int4x4 r0 = int4x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812, 953555847, 621596140, 1060334190, 211227368);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            int a1 = (290620937);
+            int4x4 b1 = int4x4(1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943);
+            int4x4 r1 = int4x4(1127638218, 648689378, 1599924796, 477936442, 631134527, 891940181, 449034364, 1108436144, 862105248, 2102275769, 343659812, 1727179960, 1141142940, 615093500, 1273803444, 439201526);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            int a2 = (714832744);
+            int4x4 b2 = int4x4(374210759, 215701593, 1573378082, 779254615, 711527976, 710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645);
+            int4x4 r2 = int4x4(1020623791, 641737521, 2002559818, 82378815, 15889728, 12609583, 667564310, 163675479, 2092654163, 949289501, 39072688, 2128928141, 2140252743, 303507938, 537080739, 1561356861);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            int a3 = (896851285);
+            int4x4 b3 = int4x4(1187420887, 536338211, 874727301, 1067319145, 191758210, 272673141, 18096431, 188062447, 1726887620, 2109517402, 1329654715, 1449815991, 342156404, 604196193, 1831114838, 962033481);
+            int4x4 r3 = int4x4(1941063554, 713228918, 22518480, 183050812, 1041834711, 624194592, 878771322, 1044465594, 1402661777, 1221096207, 2050242286, 1662956258, 554711329, 293048372, 1481655555, 203663900);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_left_shift()
+        {
+            int4x4 a0 = int4x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606);
+            int b0 = (1321149625);
+            int4x4 r0 = int4x4(1912602624, -1811939328, -1140850688, -268435456, 1644167168, -369098752, 402653184, -1744830464, -1409286144, 838860800, -872415232, -1409286144, 1006632960, 1174405120, 503316480, -1677721600);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            int4x4 a1 = int4x4(2045594989, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278, 221147365, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875);
+            int b1 = (2077023268);
+            int4x4 r1 = int4x4(-1630218544, 892924384, 469119280, 1794396016, 1406142960, 596255120, -1215170096, -1422520880, -72786848, -756609456, -1012689040, -600394240, 1142455168, -887922944, 1636751872, 648281520);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            int4x4 a2 = int4x4(1824729613, 1581610518, 407677878, 1208958192, 740058147, 946058001, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326);
+            int b2 = (1535276688);
+            int4x4 r2 = int4x4(705495040, 1981153280, -1414135808, 1022361600, 1680015360, -1290731520, 2103508992, -1426784256, 1514799104, 2144796672, 1359347712, 1840316416, -1592197120, -1565917184, -2060779520, -1424621568);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            int4x4 a3 = int4x4(1996060114, 542942787, 65869628, 622492353, 159523866, 584916657, 286195265, 1953695770, 209529707, 211278352, 933594260, 1827522668, 1129290782, 1050231977, 183969222, 1773085306);
+            int b3 = (927390277);
+            int4x4 r3 = int4x4(-550585792, 194300000, 2107828096, -1555081184, 809796416, 1537463840, 568313888, -1906244800, -1884983968, -1829027328, -189754752, -1648816768, 1777566656, -752315104, 1592047808, 904154944);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_right_shift()
+        {
+            int4x4 a0 = int4x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382);
+            int b0 = (1266801540);
+            int4x4 r0 = int4x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440, 43870498, 57361563, 35594054, 11599586);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            int4x4 a1 = int4x4(1102123711, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760, 348013684, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389);
+            int b1 = (334005460);
+            int4x4 r1 = int4x4(1051, 1549, 267, 1524, 1755, 702, 1219, 389, 728, 331, 1495, 738, 1513, 572, 28, 1793);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            int4x4 a2 = int4x4(352174824, 425441430, 186542511, 1099859381, 1234295294, 1028666766, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981);
+            int b2 = (1164508476);
+            int4x4 r2 = int4x4(1, 1, 0, 4, 4, 3, 2, 4, 3, 4, 0, 3, 4, 5, 5, 2);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            int4x4 a3 = int4x4(1435331003, 1447204571, 494777716, 1097030937, 1573721009, 424949150, 338466956, 1451909085, 2097834602, 1996022619, 1349763966, 490973311, 1133192771, 2054033380, 397231107, 150337656);
+            int b3 = (1759616654);
+            int4x4 r3 = int4x4(87605, 88330, 30198, 66957, 96052, 25936, 20658, 88617, 128041, 121827, 82383, 29966, 69164, 125368, 24245, 9175);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void int4x4_operator_bitwise_not()
+        {
+            int4x4 a0 = int4x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603);
+            int4x4 r0 = int4x4(-1403358970, -831360922, -2088190244, -976721017, -878283190, -308994340, -1935567518, -1420884857, -472965492, -771711427, -627580961, -2061524025, -753208489, -2097179284, -1303022494, -664744604);
+            TestUtils.AreEqual(~a0, r0);
+
+            int4x4 a1 = int4x4(1289372466, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942, 1562433528, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274);
+            int4x4 r1 = int4x4(-1289372467, -1951018597, -1545651938, -717936458, -1284504688, -1342785386, -869629476, -2045854322, -1282546943, -1562433529, -1824824811, -1736570716, -508906059, -2060752881, -1867418757, -388530275);
+            TestUtils.AreEqual(~a1, r1);
+
+            int4x4 a2 = int4x4(695179852, 897923626, 1816190464, 1362906829, 1227946838, 700158434, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010);
+            int4x4 r2 = int4x4(-695179853, -897923627, -1816190465, -1362906830, -1227946839, -700158435, -189609279, -956441809, -2123488811, -1593014252, -19223062, -1722107955, -1636875695, -1914097393, -1382545028, -1285277011);
+            TestUtils.AreEqual(~a2, r2);
+
+            int4x4 a3 = int4x4(722020848, 183545104, 2006881282, 685422512, 70717710, 1636059183, 1218560768, 1078350342, 1743219894, 894044458, 110742707, 1831797788, 2111543080, 858442193, 907645851, 1672993750);
+            int4x4 r3 = int4x4(-722020849, -183545105, -2006881283, -685422513, -70717711, -1636059184, -1218560769, -1078350343, -1743219895, -894044459, -110742708, -1831797789, -2111543081, -858442194, -907645852, -1672993751);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..e4939a30e1e2a6247e14e4dff530a5f49b056435
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestInt4x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 17b4cf050aaf4e44e965ec9de78ce8bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs
new file mode 100644
index 0000000000000000000000000000000000000000..992624e1350ba2f5e27718efaef31a3b6e4fad3d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs
@@ -0,0 +1,3005 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+using System;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public partial class TestMath
+    {
+        [TestCompiler]
+        public static void asint_uint()
+        {
+            TestUtils.AreEqual(asint(0u), 0);
+            TestUtils.AreEqual(asint(0x12345678u), 0x12345678);
+            TestUtils.AreEqual(asint(0x7FFFFFFFu), 0x7FFFFFFF);
+            TestUtils.AreEqual(asint(0x80000000u), -2147483648);
+            TestUtils.AreEqual(asint(0x87654321u), -2023406815);
+            TestUtils.AreEqual(asint(0xFFFFFFFFu), -1);
+        }
+
+        [TestCompiler]
+        public static void asint_uint2()
+        {
+            TestUtils.AreEqual(asint(uint2(0u, 0x12345678u)), int2(0, 0x12345678));
+            TestUtils.AreEqual(asint(uint2(0x7FFFFFFFu, 0x80000000u)), int2(0x7FFFFFFF, -2147483648));
+            TestUtils.AreEqual(asint(uint2(0x87654321u, 0xFFFFFFFFu)), int2(-2023406815, -1));
+        }
+
+        [TestCompiler]
+        public static void asint_uint3()
+        {
+            TestUtils.AreEqual(asint(uint3(0u, 0x12345678u, 0x7FFFFFFFu)), int3(0, 0x12345678, 0x7FFFFFFF));
+            TestUtils.AreEqual(asint(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu)), int3(-2147483648, -2023406815, -1));
+        }
+
+        [TestCompiler]
+        public static void asint_uint4()
+        {
+            TestUtils.AreEqual(asint(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u)), int4(0, 0x12345678, 0x7FFFFFFF, -2147483648));
+            TestUtils.AreEqual(asint(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u)), int4(-2023406815, -1, 0, 0));
+        }
+
+        [TestCompiler]
+        public static void asint_float()
+        {
+            TestUtils.AreEqual(asint(0.0f), 0);
+            TestUtils.AreEqual(asint(1.0f), 0x3F800000);
+            TestUtils.AreEqual(asint(1234.56f), 0x449A51EC);
+            TestUtils.AreEqual(asint(float.PositiveInfinity), 0x7F800000);
+            TestUtils.AreEqual(asint(float.NaN), unchecked((int)0xFFC00000));
+
+            TestUtils.AreEqual(asint(-1.0f), unchecked((int)0xBF800000));
+            TestUtils.AreEqual(asint(-1234.56f), unchecked((int)0xC49A51EC));
+            TestUtils.AreEqual(asint(float.NegativeInfinity), unchecked((int)0xFF800000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asint_float_signed_zero()
+        {
+            TestUtils.AreEqual(asint(-0.0f), unchecked((int)0x80000000));
+        }
+
+        [TestCompiler]
+        public static void asint_float2()
+        {
+            TestUtils.AreEqual(asint(float2(0.0f, 1.0f)), int2(0, 0x3F800000));
+            TestUtils.AreEqual(asint(float2(1234.56f, float.PositiveInfinity)), int2(0x449A51EC, 0x7F800000));
+            TestUtils.AreEqual(asint(float2(float.NaN, -1.0f)), int2(unchecked((int)0xFFC00000), unchecked((int)0xBF800000)));
+
+            TestUtils.AreEqual(asint(float2(-1234.56f, float.NegativeInfinity)), int2(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)));
+            TestUtils.AreEqual(asint(float2(0.0f, 0.0f)), int2(0, 0));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asint_float2_signed_zero()
+        {
+            TestUtils.AreEqual(asint(float2(-0.0f, -0.0f)), int2(unchecked((int)0x80000000), unchecked((int)0x80000000)));
+        }
+
+        [TestCompiler]
+        public static void asint_float3()
+        {
+            TestUtils.AreEqual(asint(float3(0.0f, 1.0f, 1234.56f)), int3(0, 0x3F800000, 0x449A51EC));
+            TestUtils.AreEqual(asint(float3(float.PositiveInfinity, float.NaN, -1.0f)), int3(0x7F800000, unchecked((int)0xFFC00000), unchecked((int)0xBF800000)));
+            TestUtils.AreEqual(asint(float3(-1234.56f, float.NegativeInfinity, 0.0f)), int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asint_float3_signed_zero()
+        {
+            TestUtils.AreEqual(asint(float3(-0.0f, -0.0f, -0.0f)), int3(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)));
+        }
+
+        [TestCompiler]
+        public static void asint_float4()
+        {
+            TestUtils.AreEqual(asint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)), int4(0, 0x3F800000, 0x449A51EC, 0x7F800000));
+            TestUtils.AreEqual(asint(float4(float.NaN, -1.0f, -1234.56f, float.NegativeInfinity)), int4(unchecked((int)0xFFC00000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asint_float4_signed_zero()
+        {
+            TestUtils.AreEqual(asint(float4(-0.0f, -0.0f, -0.0f, -0.0f)), int4(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)));
+        }
+
+        [TestCompiler]
+        public static void asuint_int()
+        {
+            TestUtils.AreEqual(asuint(0), 0u);
+            TestUtils.AreEqual(asuint(0x12345678), 0x12345678u);
+            TestUtils.AreEqual(asuint(0x7FFFFFFF), 0x7FFFFFFFu);
+            TestUtils.AreEqual(asuint(-2147483648), 0x80000000u);
+            TestUtils.AreEqual(asuint(-2023406815), 0x87654321u);
+            TestUtils.AreEqual(asuint(-1), 0xFFFFFFFFu);
+        }
+
+        [TestCompiler]
+        public static void asuint_int2()
+        {
+            TestUtils.AreEqual(asuint(int2(0, 0x12345678)), uint2(0u, 0x12345678u));
+            TestUtils.AreEqual(asuint(int2(0x7FFFFFFF, -2147483648)), uint2(0x7FFFFFFFu, 0x80000000u));
+            TestUtils.AreEqual(asuint(int2(-2023406815, -1)), uint2(0x87654321u, 0xFFFFFFFFu));
+        }
+
+        [TestCompiler]
+        public static void asuint_int3()
+        {
+            TestUtils.AreEqual(asuint(int3(0, 0x12345678, 0x7FFFFFFF)), uint3(0u, 0x12345678u, 0x7FFFFFFFu));
+            TestUtils.AreEqual(asuint(int3(-2147483648, -2023406815, -1)), uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu));
+        }
+
+        [TestCompiler]
+        public static void asuint_int4()
+        {
+            TestUtils.AreEqual(asuint(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648)), uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u));
+            TestUtils.AreEqual(asuint(int4(-2023406815, -1, 0, 0)), uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u));
+        }
+
+        [TestCompiler]
+        public static void asuint_float()
+        {
+            TestUtils.AreEqual(asuint(0.0f), 0u);
+            TestUtils.AreEqual(asuint(1.0f), 0x3F800000u);
+            TestUtils.AreEqual(asuint(1234.56f), 0x449A51ECu);
+            TestUtils.AreEqual(asuint(float.PositiveInfinity), 0x7F800000u);
+            TestUtils.AreEqual(asuint(float.NaN), 0xFFC00000u);
+
+            TestUtils.AreEqual(asuint(-1.0f), 0xBF800000u);
+            TestUtils.AreEqual(asuint(-1234.56f), 0xC49A51ECu);
+            TestUtils.AreEqual(asuint(float.NegativeInfinity), 0xFF800000u);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asuint_float_signed_zero()
+        {
+            TestUtils.AreEqual(asuint(-0.0f), 0x80000000u);
+        }
+
+        [TestCompiler]
+        public static void asuint_float2()
+        {
+            TestUtils.AreEqual(asuint(float2(0.0f, 1.0f)), uint2(0u, 0x3F800000u));
+            TestUtils.AreEqual(asuint(float2(1234.56f, float.PositiveInfinity)), uint2(0x449A51Ecu, 0x7F800000u));
+            TestUtils.AreEqual(asuint(float2(float.NaN, -1.0f)), uint2(0xFFC00000u, 0xBF800000u));
+
+            TestUtils.AreEqual(asuint(float2(-1234.56f, float.NegativeInfinity)), uint2(0xC49A51ECu, 0xFF800000u));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asuint_float2_signed_zero()
+        {
+            TestUtils.AreEqual(asuint(float2(-0.0f, -0.0f)), uint2(0x80000000u, 0x80000000u));
+        }
+
+        [TestCompiler]
+        public static void asuint_float3()
+        {
+            TestUtils.AreEqual(asuint(float3(0.0f, 1.0f, 1234.56f)), uint3(0u, 0x3F800000u, 0x449A51ECu));
+            TestUtils.AreEqual(asuint(float3(float.PositiveInfinity, float.NaN, -1.0f)), uint3(0x7F800000u, 0xFFC00000u, 0xBF800000u));
+            TestUtils.AreEqual(asuint(float3(-1234.56f, float.NegativeInfinity, 0.0f)), uint3(0xC49A51ECu, 0xff800000u, 0u));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asuint_float3_signed_zero()
+        {
+            TestUtils.AreEqual(asuint(float3(-0.0f, -0.0f, -0.0f)), uint3(0x80000000u, 0x80000000u, 0x80000000u));
+        }
+
+        [TestCompiler]
+        public static void asuint_float4()
+        {
+            TestUtils.AreEqual(asuint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)), uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u));
+            TestUtils.AreEqual(asuint(float4(float.NaN, -1.0f, -1234.56f, float.NegativeInfinity)), uint4(0xFFC00000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asuint_float4_singed_zero()
+        {
+            TestUtils.AreEqual(asuint(float4(-0.0f, -0.0f, -0.0f, -0.0f)), uint4(0x80000000u, 0x80000000u, 0x80000000u, 0x80000000u));
+        }
+
+        [TestCompiler]
+        public static void aslong_ulong()
+        {
+            TestUtils.AreEqual(aslong(0ul), 0L);
+            TestUtils.AreEqual(aslong(0x0123456789ABCDEFul), 0x0123456789ABCDEFL);
+            TestUtils.AreEqual(aslong(0x7FFFFFFFFFFFFFFFul), 0x7FFFFFFFFFFFFFFFL);
+            TestUtils.AreEqual(aslong(0x8000000000000000ul), -9223372036854775808L);
+            TestUtils.AreEqual(aslong(0xFEDCBA9876543210ul), -81985529216486896L);
+            TestUtils.AreEqual(aslong(0xFFFFFFFFFFFFFFFFul), -1L);
+        }
+
+        [TestCompiler]
+        public static void aslong_double()
+        {
+            TestUtils.AreEqual(aslong(0.0), 0L);
+            TestUtils.AreEqual(aslong(1.0), 0x3FF0000000000000L);
+            TestUtils.AreEqual(aslong(1234.56), 0x40934A3D70A3D70AL);
+            TestUtils.AreEqual(aslong(double.PositiveInfinity), 0x7FF0000000000000L);
+            TestUtils.AreEqual(aslong(double.NaN), unchecked((long)0xFFF8000000000000UL));
+
+            TestUtils.AreEqual(aslong(-1.0), unchecked((long)0xBFF0000000000000UL));
+            TestUtils.AreEqual(aslong(-1234.56), unchecked((long)0xC0934A3D70A3D70AUL));
+            TestUtils.AreEqual(aslong(double.NegativeInfinity), unchecked((long)0xFFF0000000000000UL));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void aslong_double_signed_zero()
+        {
+            TestUtils.AreEqual(aslong(-0.0), unchecked((long)0x8000000000000000UL));
+        }
+
+        [TestCompiler]
+        public static void asulong_long()
+        {
+            TestUtils.AreEqual(asulong(0L), 0ul);
+            TestUtils.AreEqual(asulong(0x0123456789ABCDEFL), 0x0123456789ABCDEFul);
+            TestUtils.AreEqual(asulong(0x7FFFFFFFFFFFFFFFL), 0x7FFFFFFFFFFFFFFFul);
+            TestUtils.AreEqual(asulong(-9223372036854775808L), 0x8000000000000000ul);
+            TestUtils.AreEqual(asulong(-81985529216486896L), 0xFEDCBA9876543210ul);
+            TestUtils.AreEqual(asulong(-1L), 0xFFFFFFFFFFFFFFFFul);
+        }
+
+        [TestCompiler]
+        public static void asulong_double()
+        {
+            TestUtils.AreEqual(asulong(0.0), 0UL);
+            TestUtils.AreEqual(asulong(1.0), 0x3FF0000000000000UL);
+            TestUtils.AreEqual(asulong(1234.56), 0x40934A3D70A3D70AUL);
+            TestUtils.AreEqual(asulong(double.PositiveInfinity), 0x7FF0000000000000UL);
+            TestUtils.AreEqual(asulong(double.NaN), 0xFFF8000000000000UL);
+
+            TestUtils.AreEqual(asulong(-1.0), 0xBFF0000000000000UL);
+            TestUtils.AreEqual(asulong(-1234.56), 0xC0934A3D70A3D70AUL);
+            TestUtils.AreEqual(asulong(double.NegativeInfinity), 0xFFF0000000000000UL);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void asulong_double_signed_zero()
+        {
+            TestUtils.AreEqual(asulong(-0.0), 0x8000000000000000UL);
+        }
+
+        [TestCompiler]
+        public static void asfloat_int()
+        {
+            TestUtils.AreEqual(asfloat(0), 0.0f);
+            TestUtils.AreEqual(asfloat(0x3F800000), 1.0f);
+            TestUtils.AreEqual(asfloat(0x449A51EC), 1234.56f);
+            TestUtils.AreEqual(asfloat(0x7F800000), float.PositiveInfinity);
+            TestUtils.AreEqual(asfloat(unchecked((int)0x80000000)), -0.0f);
+            TestUtils.AreEqual(asfloat(unchecked((int)0xBF800000)), -1.0f);
+            TestUtils.AreEqual(asfloat(unchecked((int)0xC49A51EC)), -1234.56f);
+            TestUtils.AreEqual(asfloat(unchecked((int)0xFF800000)), float.NegativeInfinity);
+
+            TestUtils.AreEqual(asuint(asfloat(unchecked((int)0xFFC00000))), asuint(float.NaN));
+        }
+
+        [TestCompiler]
+        public static void asfloat_int2()
+        {
+            TestUtils.AreEqual(asfloat(int2(0, 0x3F800000)), float2(0.0f, 1.0f));
+            TestUtils.AreEqual(asfloat(int2(0x449A51EC, 0x7F800000)), float2(1234.56f, float.PositiveInfinity));
+            TestUtils.AreEqual(asfloat(int2(unchecked((int)0x80000000), unchecked((int)0xBF800000))), float2(-0.0f, -1.0f));
+
+            TestUtils.AreEqual(asfloat(int2(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000))), float2(-1234.56f, float.NegativeInfinity));
+            TestUtils.AreEqual(asuint(asfloat(int2(unchecked((int)0xFFC00000), unchecked((int)0xFFC00000)))), asuint(float2(float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asfloat_int3()
+        {
+            TestUtils.AreEqual(asfloat(int3(0, 0x3F800000, 0x449A51EC)), float3(0.0f, 1.0f, 1234.56f));
+            TestUtils.AreEqual(asfloat(int3(0x7F800000, unchecked((int)0x80000000), unchecked((int)0xBF800000))), float3(float.PositiveInfinity, -0.0f, -1.0f));
+
+            TestUtils.AreEqual(asfloat(int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0)), float3(-1234.56f, float.NegativeInfinity, 0.0f));
+            TestUtils.AreEqual(asuint(asfloat(int3(unchecked((int)0xFFC00000), unchecked((int)0xFFC00000), unchecked((int)0xFFC00000)))), asuint(float3(float.NaN, float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asfloat_int4()
+        {
+            TestUtils.AreEqual(asfloat(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000)), float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity));
+            TestUtils.AreEqual(asfloat(int4(unchecked((int)0x80000000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000))), float4(-0.0f, -1.0f, -1234.56f, float.NegativeInfinity));
+
+            TestUtils.AreEqual(asuint(asfloat(int4(unchecked((int)0xFFC00000), unchecked((int)0xFFC00000), unchecked((int)0xFFC00000), unchecked((int)0xFFC00000)))), asuint(float4(float.NaN, float.NaN, float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asfloat_uint()
+        {
+            TestUtils.AreEqual(asfloat(0u), 0.0f);
+            TestUtils.AreEqual(asfloat(0x3F800000u), 1.0f);
+            TestUtils.AreEqual(asfloat(0x449A51ECu), 1234.56f);
+            TestUtils.AreEqual(asfloat(0x7F800000u), float.PositiveInfinity);
+            TestUtils.AreEqual(asfloat(0x80000000u), -0.0f);
+            TestUtils.AreEqual(asfloat(0xBF800000u), -1.0f);
+            TestUtils.AreEqual(asfloat(0xC49A51ECu), -1234.56f);
+            TestUtils.AreEqual(asfloat(0xFF800000u), float.NegativeInfinity);
+
+            TestUtils.AreEqual(asuint(asfloat(0xFFC00000u)), asuint(float.NaN));
+        }
+
+        [TestCompiler]
+        public static void asfloat_uint2()
+        {
+            TestUtils.AreEqual(asfloat(uint2(0u, 0x3F800000u)), float2(0.0f, 1.0f));
+            TestUtils.AreEqual(asfloat(uint2(0x449A51ECu, 0x7F800000u)), float2(1234.56f, float.PositiveInfinity));
+            TestUtils.AreEqual(asfloat(uint2(0x80000000u, 0xBF800000u)), float2(-0.0f, -1.0f));
+
+            TestUtils.AreEqual(asfloat(uint2(0xC49A51ECu, 0xFF800000u)), float2(-1234.56f, float.NegativeInfinity));
+            TestUtils.AreEqual(asuint(asfloat(uint2(0xFFC00000u, 0xFFC00000u))), asuint(float2(float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asfloat_uint3()
+        {
+            TestUtils.AreEqual(asfloat(uint3(0u, 0x3F800000u, 0x449A51ECu)), float3(0.0f, 1.0f, 1234.56f));
+            TestUtils.AreEqual(asfloat(uint3(0x7F800000u, 0x80000000u, 0xBF800000u)), float3(float.PositiveInfinity, -0.0f, -1.0f));
+
+            TestUtils.AreEqual(asfloat(uint3(0xC49A51ECu, 0xFF800000u, 0u)), float3(-1234.56f, float.NegativeInfinity, 0.0f));
+            TestUtils.AreEqual(asuint(asfloat(uint3(0xFFC00000u, 0xFFC00000u, 0xFFC00000u))), asuint(float3(float.NaN, float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asfloat_uint4()
+        {
+            TestUtils.AreEqual(asfloat(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u)), float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity));
+            TestUtils.AreEqual(asfloat(uint4(0x80000000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u)), float4(-0.0f, -1.0f, -1234.56f, float.NegativeInfinity));
+
+            TestUtils.AreEqual(asuint(asfloat(uint4(0xFFC00000u, 0xFFC00000u, 0xFFC00000u, 0xFFC00000u))), asuint(float4(float.NaN, float.NaN, float.NaN, float.NaN)));
+        }
+
+        [TestCompiler]
+        public static void asdouble_long()
+        {
+            TestUtils.AreEqual(asdouble(0L), 0.0);
+            TestUtils.AreEqual(asdouble(0x3FF0000000000000L), 1.0);
+            TestUtils.AreEqual(asdouble(0x40934A3D70A3D70AL), 1234.56);
+            TestUtils.AreEqual(asdouble(0x7FF0000000000000L), double.PositiveInfinity);
+            TestUtils.AreEqual(asdouble(unchecked((long)0xFFF8000000000000UL)), double.NaN);
+
+            TestUtils.AreEqual(asdouble(unchecked((long)0x8000000000000000UL)), -0.0);
+            TestUtils.AreEqual(asdouble(unchecked((long)0xBFF0000000000000UL)), -1.0);
+            TestUtils.AreEqual(asdouble(unchecked((long)0xC0934A3D70A3D70AUL)), -1234.56);
+            TestUtils.AreEqual(asdouble(unchecked((long)0xFFF0000000000000UL)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void asdouble_ulong()
+        {
+            TestUtils.AreEqual(asdouble(0UL), 0.0);
+            TestUtils.AreEqual(asdouble(0x3FF0000000000000UL), 1.0);
+            TestUtils.AreEqual(asdouble(0x40934A3D70A3D70AUL), 1234.56);
+            TestUtils.AreEqual(asdouble(0x7FF0000000000000UL), double.PositiveInfinity);
+            TestUtils.AreEqual(asdouble(0xFFF8000000000000UL), double.NaN);
+
+            TestUtils.AreEqual(asdouble(0x8000000000000000UL), -0.0);
+            TestUtils.AreEqual(asdouble(0xBFF0000000000000UL), -1.0);
+            TestUtils.AreEqual(asdouble(0xC0934A3D70A3D70AUL), -1234.56);
+            TestUtils.AreEqual(asdouble(0xFFF0000000000000UL), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void faceforward_float2()
+        {
+            TestUtils.AreEqual(faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(3.0f, -4.0f)), float2(-3.5f, 4.5f));
+            TestUtils.AreEqual(faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(-3.0f, 4.0f)), float2(3.5f, -4.5f));
+            TestUtils.AreEqual(faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(0.0f, 0.0f)), float2(-3.5f, 4.5f));
+        }
+
+        [TestCompiler]
+        public static void faceforward_float3()
+        {
+            TestUtils.AreEqual(faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(3.0f, -4.0f, 5.0f)), float3(-3.5f, 4.5f, -5.5f));
+            TestUtils.AreEqual(faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(-3.0f, 4.0f, -5.0f)), float3(3.5f, -4.5f, 5.5f));
+            TestUtils.AreEqual(faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(0.0f, 0.0f, 0.0f)), float3(-3.5f, 4.5f, -5.5f));
+        }
+
+        [TestCompiler]
+        public static void faceforward_float4()
+        {
+            TestUtils.AreEqual(faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(3.0f, -4.0f, 5.0f, -6.0f)), float4(-3.5f, 4.5f, -5.5f, 6.5f));
+            TestUtils.AreEqual(faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(-3.0f, 4.0f, -5.0f, 6.0f)), float4(3.5f, -4.5f, 5.5f, -6.5f));
+            TestUtils.AreEqual(faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(0.0f, 0.0f, 0.0f, 0.0f)), float4(-3.5f, 4.5f, -5.5f, 6.5f));
+        }
+
+        [TestCompiler]
+        public static void faceforward_double2()
+        {
+            TestUtils.AreEqual(faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(3.0, -4.0)), double2(-3.5, 4.5));
+            TestUtils.AreEqual(faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(-3.0, 4.0)), double2(3.5, -4.5));
+            TestUtils.AreEqual(faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(0.0, 0.0)), double2(-3.5, 4.5));
+        }
+
+        [TestCompiler]
+        public static void faceforward_double3()
+        {
+            TestUtils.AreEqual(faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(3.0, -4.0, 5.0)), double3(-3.5, 4.5, -5.5));
+            TestUtils.AreEqual(faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(-3.0, 4.0, -5.0)), double3(3.5, -4.5, 5.5));
+            TestUtils.AreEqual(faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(0.0, 0.0, 0.0)), double3(-3.5, 4.5, -5.5));
+        }
+
+        [TestCompiler]
+        public static void faceforward_double4()
+        {
+            TestUtils.AreEqual(faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(3.0, -4.0, 5.0, -6.0)), double4(-3.5, 4.5, -5.5, 6.5));
+            TestUtils.AreEqual(faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(-3.0, 4.0, -5.0, 6.0)), double4(3.5, -4.5, 5.5, -6.5));
+            TestUtils.AreEqual(faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(0.0, 0.0, 0.0, 0.0)), double4(-3.5, 4.5, -5.5, 6.5));
+        }
+
+        [TestCompiler]
+        public static void modf_float()
+        {
+            float f, i;
+            f = modf(313.75f, out i);
+            TestUtils.AreEqual(i, 313.0f);
+            TestUtils.AreEqual(f, 0.75f);
+
+            f = modf(-313.25f, out i);
+            TestUtils.AreEqual(i, -313.0f);
+            TestUtils.AreEqual(f, -0.25f);
+
+            f = modf(-314.0f, out i);
+            TestUtils.AreEqual(i, -314.0f);
+            TestUtils.AreEqual(f, 0.0f);
+        }
+
+        [TestCompiler]
+        public static void modf_float2()
+        {
+            float2 f, i;
+            f = modf(float2(313.75f, -313.25f), out i);
+            TestUtils.AreEqual(i, float2(313.0f, -313.0f));
+            TestUtils.AreEqual(f, float2(0.75f, -0.25f));
+
+            f = modf(float2(-314.0f, 7.5f), out i);
+            TestUtils.AreEqual(i, float2(-314.0f, 7.0f));
+            TestUtils.AreEqual(f, float2(0.0f, 0.5f));
+        }
+
+        [TestCompiler]
+        public static void modf_float3()
+        {
+            float3 f, i;
+            f = modf(float3(313.75f, -313.25f, -314.0f), out i);
+            TestUtils.AreEqual(i, float3(313.0f, -313.0f, -314.0f));
+            TestUtils.AreEqual(f, float3(0.75f, -0.25f, 0.0f));
+        }
+
+        [TestCompiler]
+        public static void modf_float4()
+        {
+            float4 f, i;
+            f = modf(float4(313.75f, -313.25f, -314.0f, 7.5f), out i);
+            TestUtils.AreEqual(i, float4(313.0f, -313.0f, -314.0f, 7.0f));
+            TestUtils.AreEqual(f, float4(0.75f, -0.25f, 0.0f, 0.5f));
+        }
+
+        [TestCompiler]
+        public static void modf_double()
+        {
+            double f, i;
+            f = modf(313.75, out i);
+            TestUtils.AreEqual(i, 313.0);
+            TestUtils.AreEqual(f, 0.75);
+
+            f = modf(-313.25, out i);
+            TestUtils.AreEqual(i, -313.0);
+            TestUtils.AreEqual(f, -0.25);
+
+            f = modf(-314.0, out i);
+            TestUtils.AreEqual(i, -314.0);
+            TestUtils.AreEqual(f, 0.0);
+        }
+
+        [TestCompiler]
+        public static void modf_double2()
+        {
+            double2 f, i;
+            f = modf(double2(313.75, -313.25), out i);
+            TestUtils.AreEqual(i, double2(313.0, -313.0));
+            TestUtils.AreEqual(f, double2(0.75, -0.25));
+
+            f = modf(double2(-314.0, 7.5), out i);
+            TestUtils.AreEqual(i, double2(-314.0, 7.0));
+            TestUtils.AreEqual(f, double2(0.0, 0.5));
+        }
+
+        [TestCompiler]
+        public static void modf_double3()
+        {
+            double3 f, i;
+            f = modf(double3(313.75, -313.25, -314.0), out i);
+            TestUtils.AreEqual(i, double3(313.0, -313.0, -314.0));
+            TestUtils.AreEqual(f, double3(0.75, -0.25, 0.0));
+        }
+
+        [TestCompiler]
+        public static void modf_double4()
+        {
+            double4 f, i;
+            f = modf(double4(313.75, -313.25, -314.0, 7.5), out i);
+            TestUtils.AreEqual(i, double4(313.0, -313.0, -314.0, 7.0));
+            TestUtils.AreEqual(f, double4(0.75, -0.25, 0.0, 0.5f));
+        }
+
+        [TestCompiler]
+        public static void normalize_float2()
+        {
+            TestUtils.AreEqual(normalize(float2(3.1f, -5.3f)), float2(0.504883f, -0.863188f), 0.0001f);
+            TestUtils.AreEqual(all(isnan(normalize(float2(0.0f, 0.0f)))), true);
+        }
+
+        [TestCompiler]
+        public static void normalize_float3()
+        {
+            TestUtils.AreEqual(normalizesafe(float3(3.1f, -5.3f, 2.6f)), float3(0.464916f, -0.794861f, 0.389932f), 0.0001f);
+            TestUtils.AreEqual(all(isnan(normalize(float3(0.0f, 0.0f, 0.0f)))), true);
+        }
+
+        [TestCompiler]
+        public static void normalize_float4()
+        {
+            TestUtils.AreEqual(normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), 0.0001f);
+            TestUtils.AreEqual(all(isnan(normalize(float4(0.0f, 0.0f, 0.0f, 0.0f)))), true);
+        }
+
+
+        [TestCompiler]
+        public static void normalize_double2()
+        {
+            TestUtils.AreEqual(normalize(double2(3.1, -5.3)), double2(0.504883, -0.863188), 0.0001);
+            TestUtils.AreEqual(all(isnan(normalize(double2(0.0, 0.0)))), true);
+        }
+
+        [TestCompiler]
+        public static void normalize_double3()
+        {
+            TestUtils.AreEqual(normalizesafe(double3(3.1, -5.3, 2.6)), double3(0.464916, -0.794861, 0.389932), 0.0001);
+            TestUtils.AreEqual(all(isnan(normalize(double3(0.0, 0.0, 0.0)))), true);
+        }
+
+        [TestCompiler]
+        public static void normalize_double4()
+        {
+            TestUtils.AreEqual(normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), double4(0.234727, -0.401308, 0.196868, 0.863191), 0.0001);
+            TestUtils.AreEqual(all(isnan(normalize(double4(0.0, 0.0, 0.0, 0.0f)))), true);
+        }
+
+        [TestCompiler]
+        public static void normalize_quaternion()
+        {
+            TestUtils.AreEqual(normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), 0.0001f);
+            TestUtils.AreEqual(all(isnan(normalize(quaternion(0.0f, 0.0f, 0.0f, 0.0f)).value)), true);
+        }
+
+
+        [TestCompiler]
+        public static void normalizesafe_float2()
+        {
+            TestUtils.AreEqual(normalizesafe(float2(3.1f, -5.3f)), float2(0.504883f, -0.863188f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float2(0.0f, 0.0f)), float2(0.0f, 0.0f));
+            TestUtils.AreEqual(normalizesafe(float2(0.0f, 0.0f), float2(1.0f, 2.0f)), float2(1.0f, 2.0f));
+            TestUtils.AreEqual(normalizesafe(float2(1e-18f, 2e-18f)), float2(0.447214f, 0.894427f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float2(7.66e-20f, 7.66e-20f), float2(1.0f, 2.0f)), float2(1.0f, 2.0f));
+        }
+
+        [TestCompiler]
+        public static void normalizesafe_float3()
+        {
+            TestUtils.AreEqual(normalizesafe(float3(3.1f, -5.3f, 2.6f)), float3(0.464916f, -0.794861f, 0.389932f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float3(0.0f, 0.0f, 0.0f)), float3(0.0f, 0.0f, 0.0f));
+            TestUtils.AreEqual(normalizesafe(float3(0.0f, 0.0f, 0.0f), float3(1.0f, 2.0f, 3.0f)), float3(1.0f, 2.0f, 3.0f));
+            TestUtils.AreEqual(normalizesafe(float3(1e-19f, 2e-19f, 3e-19f)), float3(0.267261f, 0.534523f, 0.801784f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float3(6.25e-20f, 6.25e-20f, 6.25e-20f), float3(1.0f, 2.0f, 3.0f)), float3(1.0f, 2.0f, 3.0f));
+        }
+
+        [TestCompiler]
+        public static void normalizesafe_float4()
+        {
+            TestUtils.AreEqual(normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float4(0.0f, 0.0f, 0.0f, 0.0f)), float4(0.0f, 0.0f, 0.0f, 0.0f));
+            TestUtils.AreEqual(normalizesafe(float4(0.0f, 0.0f, 0.0f, 0.0f), float4(1.0f, 2.0f, 3.0f, 4.0f)), float4(1.0f, 2.0f, 3.0f, 4.0f));
+            TestUtils.AreEqual(normalizesafe(float4(1e-19f, 2e-19f, 3e-19f, 4e-19f)), float4(0.182574f, 0.3651484f, 0.547723f, 0.730297f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(float4(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), float4(1.0f, 2.0f, 3.0f, 4.0f)), float4(1.0f, 2.0f, 3.0f, 4.0f));
+        }
+
+
+        [TestCompiler]
+        public static void normalizesafe_double2()
+        {
+            TestUtils.AreEqual(normalizesafe(double2(3.1, -5.3)), double2(0.504883, -0.863188), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double2(0.0, 0.0)), double2(0.0, 0.0));
+            TestUtils.AreEqual(normalizesafe(double2(0.0, 0.0), double2(1.0, 2.0)), double2(1.0, 2.0));
+            TestUtils.AreEqual(normalizesafe(double2(1e-18, 2e-18)), double2(0.447214, 0.894427), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double2(1.05e-154, 1.05e-154), double2(1.0, 2.0)), double2(1.0, 2.0));
+        }
+
+        [TestCompiler]
+        public static void normalizesafe_double3()
+        {
+            TestUtils.AreEqual(normalizesafe(double3(3.1, -5.3, 2.6)), double3(0.464916, -0.794861, 0.389932), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double3(0.0, 0.0, 0.0)), double3(0.0, 0.0, 0.0));
+            TestUtils.AreEqual(normalizesafe(double3(0.0, 0.0, 0.0), double3(1.0, 2.0, 3.0)), double3(1.0, 2.0, 3.0));
+            TestUtils.AreEqual(normalizesafe(double3(1e-19, 2e-19, 3e-19)), double3(0.267261, 0.534523, 0.801784), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double3(8.61e-155, 8.61e-155, 8.61e-155), double3(1.0, 2.0, 3.0)), double3(1.0, 2.0, 3.0));
+        }
+
+        [TestCompiler]
+        public static void normalizesafe_double4()
+        {
+            TestUtils.AreEqual(normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), double4(0.234727, -0.401308, 0.196868, 0.863191), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double4(0.0, 0.0, 0.0, 0.0)), double4(0.0, 0.0, 0.0, 0.0));
+            TestUtils.AreEqual(normalizesafe(double4(0.0, 0.0, 0.0, 0.0), double4(1.0, 2.0, 3.0, 4.0)), double4(1.0, 2.0, 3.0, 4.0));
+            TestUtils.AreEqual(normalizesafe(double4(1e-19, 2e-19, 3e-19, 4e-19)), double4(0.182574, 0.3651484, 0.547723, 0.730297), 0.0001);
+            TestUtils.AreEqual(normalizesafe(double4(7.45e-155, 7.45e-155, 7.45e-155, 7.45e-155), double4(1.0, 2.0, 3.0, 4.0)), double4(1.0, 2.0, 3.0, 4.0));
+        }
+
+        [TestCompiler]
+        public static void normalizesafe_quaternion()
+        {
+            TestUtils.AreEqual(normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(quaternion(0.0f, 0.0f, 0.0f, 0.0f)), quaternion(0.0f, 0.0f, 0.0f, 1.0f));
+            TestUtils.AreEqual(normalizesafe(quaternion(0.0f, 0.0f, 0.0f, 0.0f), quaternion(1.0f, 2.0f, 3.0f, 4.0f)), quaternion(1.0f, 2.0f, 3.0f, 4.0f));
+            TestUtils.AreEqual(normalizesafe(quaternion(1e-19f, 2e-19f, 3e-19f, 4e-19f)), quaternion(0.182574f, 0.3651484f, 0.547723f, 0.730297f), 0.0001f);
+            TestUtils.AreEqual(normalizesafe(quaternion(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), quaternion(1.0f, 2.0f, 3.0f, 4.0f)), quaternion(1.0f, 2.0f, 3.0f, 4.0f));
+        }
+
+        [TestCompiler]
+        public static void f16tof32_float()
+        {
+            TestUtils.AreEqual(asuint(f16tof32(0x0000)), 0x00000000);
+            TestUtils.AreEqual(asuint(f16tof32(0x0203)), 0x3800C000);
+            TestUtils.AreEqual(asuint(f16tof32(0x4321)), 0x40642000);
+            TestUtils.AreEqual(asuint(f16tof32(0x7BFF)), 0x477FE000);
+            TestUtils.AreEqual(asuint(f16tof32(0x7C00)), 0x7F800000);
+            TestUtils.AreEqual(isnan(f16tof32(0x7C01)), true);
+
+            TestUtils.AreEqual(asuint(f16tof32(0x8000)), 0x80000000);
+            TestUtils.AreEqual(asuint(f16tof32(0x8203)), 0xB800C000);
+            TestUtils.AreEqual(asuint(f16tof32(0xC321)), 0xC0642000);
+            TestUtils.AreEqual(asuint(f16tof32(0xFBFF)), 0xC77FE000);
+            TestUtils.AreEqual(asuint(f16tof32(0xFC00)), 0xFF800000);
+            TestUtils.AreEqual(isnan(f16tof32(0xFC01)), true);
+        }
+
+        [TestCompiler]
+        public static void f16tof32_float2()
+        {
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0x0000, 0x0203))), uint2(0x00000000, 0x3800C000));
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0x4321, 0x7BFF))), uint2(0x40642000, 0x477FE000));
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0x7C00, 0x7C00))), uint2(0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint2(0x7C01, 0x7C01)))), true);
+
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0x8000, 0x8203))), uint2(0x80000000, 0xB800C000));
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0xC321, 0xFBFF))), uint2(0xC0642000, 0xC77FE000));
+            TestUtils.AreEqual(asuint(f16tof32(uint2(0xFC00, 0xFC00))), uint2(0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint2(0xFC01, 0xFC01)))), true);
+        }
+
+        [TestCompiler]
+        public static void f16tof32_float3()
+        {
+            TestUtils.AreEqual(asuint(f16tof32(uint3(0x0000, 0x0203, 0x4321))), uint3(0x00000000, 0x3800C000, 0x40642000));
+            TestUtils.AreEqual(asuint(f16tof32(uint3(0x7BFF, 0x7C00, 0x7C00))), uint3(0x477FE000, 0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint3(0x7C01, 0x7C01, 0x7C01)))), true);
+
+            TestUtils.AreEqual(asuint(f16tof32(uint3(0x8000, 0x8203, 0xC321))), uint3(0x80000000, 0xB800C000, 0xC0642000));
+            TestUtils.AreEqual(asuint(f16tof32(uint3(0xFBFF, 0xFC00, 0xFC00))), uint3(0xC77FE000, 0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint3(0xFC01, 0xFC01, 0xFC01)))), true);
+        }
+
+        [TestCompiler]
+        public static void f16tof32_float4()
+        {
+            TestUtils.AreEqual(asuint(f16tof32(uint4(0x0000, 0x0203, 0x4321, 0x7BFF))), uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000));
+            TestUtils.AreEqual(asuint(f16tof32(uint4(0x7C00, 0x7C00, 0x7C00, 0x7C00))), uint4(0x7F800000, 0x7F800000, 0x7F800000, 0x7F800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint4(0x7C01, 0x7C01, 0x7C01, 0x7C01)))), true);
+
+            TestUtils.AreEqual(asuint(f16tof32(uint4(0x8000, 0x8203, 0xC321, 0xFBFF))), uint4(0x80000000, 0xB800C000, 0xC0642000, 0xC77FE000));
+            TestUtils.AreEqual(asuint(f16tof32(uint4(0xFC00, 0xFC00, 0xFC00, 0xFC00))), uint4(0xFF800000, 0xFF800000, 0xFF800000, 0xFF800000));
+            TestUtils.AreEqual(all(isnan(f16tof32(uint4(0xFC01, 0xFC01, 0xFC01, 0xFC01)))), true);
+        }
+
+        [TestCompiler]
+        public static void f32tof16_float()
+        {
+            TestUtils.AreEqual(f32tof16(0.0f), 0x0000);
+            TestUtils.AreEqual(f32tof16(2.98e-08f), 0x0000);
+            TestUtils.AreEqual(f32tof16(5.96046448e-08f), 0x0001);
+            TestUtils.AreEqual(f32tof16(123.4f), 0x57B6);
+            TestUtils.AreEqual(f32tof16(65504.0f), 0x7BFF);
+            TestUtils.AreEqual(f32tof16(65520.0f), 0x7C00);
+            TestUtils.AreEqual(f32tof16(float.PositiveInfinity), 0x7C00);
+            TestUtils.AreEqual(f32tof16(float.NaN), 0xFE00);
+
+            TestUtils.AreEqual(f32tof16(-2.98e-08f), 0x8000);
+            TestUtils.AreEqual(f32tof16(-5.96046448e-08f), 0x8001);
+            TestUtils.AreEqual(f32tof16(-123.4f), 0xD7B6);
+            TestUtils.AreEqual(f32tof16(-65504.0f), 0xFBFF);
+            TestUtils.AreEqual(f32tof16(-65520.0f), 0xFC00);
+            TestUtils.AreEqual(f32tof16(float.NegativeInfinity), 0xFC00);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void f32tof16_float_signed_zero()
+        {
+            TestUtils.AreEqual(f32tof16(-0.0f), 0x8000);
+        }
+
+        [TestCompiler]
+        public static void f32tof16_float2()
+        {
+            TestUtils.AreEqual(f32tof16(float2(0.0f, 2.98e-08f)), uint2(0x0000, 0x0000));
+            TestUtils.AreEqual(f32tof16(float2(5.96046448e-08f, 123.4f)), uint2(0x0001, 0x57B6));
+            TestUtils.AreEqual(f32tof16(float2(65504.0f, 65520.0f)), uint2(0x7BFF, 0x7C00));
+            TestUtils.AreEqual(f32tof16(float2(float.PositiveInfinity, float.NaN)), uint2(0x7C00, 0xFE00));
+
+            TestUtils.AreEqual(f32tof16(float2(-2.98e-08f, -5.96046448e-08f)), uint2(0x8000, 0x8001));
+            TestUtils.AreEqual(f32tof16(float2(-123.4f, -65504.0f)), uint2(0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(f32tof16(float2(-65520.0f, float.NegativeInfinity)), uint2(0xFC00, 0xFC00));
+            TestUtils.AreEqual(f32tof16(float2(float.NegativeInfinity, 0.0f)), uint2(0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void f32tof16_float2_signed_zero()
+        {
+            TestUtils.AreEqual(f32tof16(float2(-0.0f, -0.0f)), uint2(0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void f32tof16_float3()
+        {
+            TestUtils.AreEqual(f32tof16(float3(0.0f, 2.98e-08f, 5.96046448e-08f)), uint3(0x0000, 0x0000, 0x0001));
+            TestUtils.AreEqual(f32tof16(float3(123.4f, 65504.0f, 65520.0f)), uint3(0x57B6, 0x7BFF, 0x7C00));
+            TestUtils.AreEqual(f32tof16(float3(float.PositiveInfinity, float.NaN, -2.98e-08f)), uint3(0x7C00, 0xFE00, 0x8000));
+
+            TestUtils.AreEqual(f32tof16(float3(-5.96046448e-08f, -123.4f, -65504.0f)), uint3(0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(f32tof16(float3(-65520.0f, float.NegativeInfinity, 0.0f)), uint3(0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void f32tof16_float3_signed_zero()
+        {
+            TestUtils.AreEqual(f32tof16(float3(-0.0f, -0.0f, -0.0f)), uint3(0x8000, 0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void f32tof16_float4()
+        {
+            TestUtils.AreEqual(f32tof16(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f)), uint4(0x0000, 0x0000, 0x0001, 0x57B6));
+            TestUtils.AreEqual(f32tof16(float4(65504.0f, 65520.0f, float.PositiveInfinity, float.NaN)), uint4(0x7BFF, 0x7C00, 0x7C00, 0xFE00));
+            TestUtils.AreEqual(f32tof16(float4(-2.98e-08f, -5.96046448e-08f, -123.4f, -65504.0f)), uint4(0x8000, 0x8001, 0xD7B6, 0xFBFF));
+            TestUtils.AreEqual(f32tof16(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f)), uint4(0xFC00, 0xFC00, 0xFC00, 0x0000));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void f32tof16_float4_signed_zero()
+        {
+            TestUtils.AreEqual(f32tof16(float4(-0.0f, -0.0f, -0.0f, -0.0f)), uint4(0x8000, 0x8000, 0x8000, 0x8000));
+        }
+
+        [TestCompiler]
+        public static void reflect_float2()
+        {
+            TestUtils.AreEqual(reflect(float2(1.2f, 3.6f), float2(1.5f, -1.3f)), float2(9.84f, -3.888f), 8, false);
+            TestUtils.AreEqual(reflect(float2(-1.2f, 3.6f), float2(-1.5f, -1.3f)), float2(-9.84f, -3.888f), 8, false);
+            TestUtils.AreEqual(reflect(float2(-1.2f, 3.6f), float2(0.0f, 0.0f)), float2(-1.2f, 3.6f));
+            TestUtils.AreEqual(reflect(float2(0.0f, 0.0f), float2(-1.5f, -1.3f)), float2(0.0f, 0.0f), 8, false);
+        }
+
+        [TestCompiler]
+        public static void reflect_float3()
+        {
+            TestUtils.AreEqual(reflect(float3(1.2f, 3.6f, -2.8f), float3(1.5f, -1.3f, 3.1f)), float3(35.88f, -26.456f, 68.872f), 8, false);
+            TestUtils.AreEqual(reflect(float3(-1.2f, 3.6f, -2.8f), float3(-1.5f, -1.3f, 3.1f)), float3(-35.88f, -26.456f, 68.872f), 8, false);
+            TestUtils.AreEqual(reflect(float3(-1.2f, 3.6f, -2.8f), float3(0.0f, 0.0f, 0.0f)), float3(-1.2f, 3.6f, -2.8f));
+            TestUtils.AreEqual(reflect(float3(0.0f, 0.0f, 0.0f), float3(-1.5f, -1.3f, 3.1f)), float3(0.0f, 0.0f, 0.0f), 8, false);
+        }
+
+        [TestCompiler]
+        public static void reflect_float4()
+        {
+            TestUtils.AreEqual(reflect(float4(1.2f, 3.6f, -2.8f, 0.3f), float4(1.5f, -1.3f, 3.1f, -0.7f)), float4(36.51f, -27.002f, 70.174f, -16.178f), 8, false);
+            TestUtils.AreEqual(reflect(float4(-1.2f, 3.6f, -2.8f, 0.3f), float4(-1.5f, -1.3f, 3.1f, -0.7f)), float4(-36.51f, -27.002f, 70.174f, -16.178f), 8, false);
+            TestUtils.AreEqual(reflect(float4(-1.2f, 3.6f, -2.8f, 0.3f), float4(0.0f, 0.0f, 0.0f, 0.0f)), float4(-1.2f, 3.6f, -2.8f, 0.3f));
+            TestUtils.AreEqual(reflect(float4(0.0f, 0.0f, 0.0f, 0.0f), float4(-1.5f, -1.3f, 3.1f, -0.7f)), float4(0.0f, 0.0f, 0.0f, 0.0f), 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void reflect_double2()
+        {
+            TestUtils.AreEqual(reflect(double2(1.2, 3.6), double2(1.5, -1.3)), double2(9.84, -3.888), 8, false);
+            TestUtils.AreEqual(reflect(double2(-1.2, 3.6), double2(-1.5, -1.3)), double2(-9.84, -3.888), 8, false);
+            TestUtils.AreEqual(reflect(double2(-1.2, 3.6), double2(0.0, 0.0)), double2(-1.2, 3.6));
+            TestUtils.AreEqual(reflect(double2(0.0, 0.0), double2(-1.5, -1.3)), double2(0.0, 0.0), 8, false);
+        }
+
+        [TestCompiler]
+        public static void reflect_double3()
+        {
+            TestUtils.AreEqual(reflect(double3(1.2, 3.6, -2.8), double3(1.5, -1.3, 3.1)), double3(35.88, -26.456, 68.872), 8, false);
+            TestUtils.AreEqual(reflect(double3(-1.2, 3.6, -2.8), double3(-1.5, -1.3, 3.1)), double3(-35.88, -26.456, 68.872), 8, false);
+            TestUtils.AreEqual(reflect(double3(-1.2, 3.6, -2.8), double3(0.0, 0.0, 0.0)), double3(-1.2, 3.6, -2.8));
+            TestUtils.AreEqual(reflect(double3(0.0, 0.0, 0.0), double3(-1.5f, -1.3, 3.1)), double3(0.0, 0.0, 0.0), 8, false);
+        }
+
+        [TestCompiler]
+        public static void reflect_double4()
+        {
+            TestUtils.AreEqual(reflect(double4(1.2, 3.6, -2.8, 0.3), double4(1.5, -1.3, 3.1, -0.7)), double4(36.51, -27.002, 70.174, -16.178), 8, false);
+            TestUtils.AreEqual(reflect(double4(-1.2, 3.6, -2.8, 0.3), double4(-1.5, -1.3, 3.1, -0.7)), double4(-36.51, -27.002, 70.174, -16.178), 8, false);
+            TestUtils.AreEqual(reflect(double4(-1.2, 3.6, -2.8, 0.3), double4(0.0, 0.0, 0.0, 0.0)), double4(-1.2, 3.6, -2.8, 0.3));
+            TestUtils.AreEqual(reflect(double4(0.0, 0.0, 0.0, 0.0), double4(-1.5, -1.3, 3.1, -0.7)), double4(0.0, 0.0, 0.0, 0.0), 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void refract_float2()
+        {
+            TestUtils.AreEqual(refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 0.5f), float2(-0.3676186f, 0.9299768f), 8, false);
+            TestUtils.AreEqual(refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.05f), float2(0.4523711f, 0.8918296f), 8, false);
+            TestUtils.AreEqual(refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.5f), float2(0.0f, 0.0f));
+        }
+
+        [TestCompiler]
+        public static void refract_float3()
+        {
+            TestUtils.AreEqual(refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 0.5f), float3(-0.2863437f, 0.8056898f, -0.5185286f), 8, false);
+            TestUtils.AreEqual(refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.05f), float3(0.3743219f, 0.8463902f, -0.3788242f), 8, false);
+            TestUtils.AreEqual(refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.5f), float3(0.0f, 0.0f, 0.0f));
+        }
+
+        [TestCompiler]
+        public static void refract_float4()
+        {
+            TestUtils.AreEqual(refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.1726139f), 0.5f), float4(-0.302029191645545f, 0.799522577847971f, -0.518952508802814f, -0.015196476378571f), 16, false);
+            TestUtils.AreEqual(refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.172613f), 1.05f), float4(0.378159678850401f, 0.801565792862319f, -0.352947832589293f, -0.299860642333894f), 16, false);
+            TestUtils.AreEqual(refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.172613f), 1.5f), float4(0.0f, 0.0f, 0.0f, 0.0f));
+        }
+
+
+        [TestCompiler]
+        public static void refract_double2()
+        {
+            TestUtils.AreEqual(refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 0.5), double2(-0.367618540673032, 0.929976739623085), 8, false);
+            TestUtils.AreEqual(refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.05), double2(0.452371226326029, 0.891829482258995), 8, false);
+            TestUtils.AreEqual(refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.5), double2(0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void refract_double3()
+        {
+            TestUtils.AreEqual(refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 0.5), double3(-0.286343746291412, 0.805689753507206, -0.518528611485079), 8, false);
+            TestUtils.AreEqual(refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.05), double3(0.374321889019825, 0.846390167376268, -0.378824161567529), 8, false);
+            TestUtils.AreEqual(refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.5), double3(0.0, 0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void refract_double4()
+        {
+            TestUtils.AreEqual(refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.1726139), 0.5), double4(-0.302029191645545, 0.799522577847971, -0.518952508802814, -0.015196476378571), 16, false);
+            TestUtils.AreEqual(refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.05), double4(0.378159678850401, 0.801565792862319, -0.352947832589293, -0.299860642333894), 16, false);
+            TestUtils.AreEqual(refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.5), double4(0.0, 0.0, 0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void sincos_float()
+        {
+            float s, c;
+
+            sincos(-1000000f, out s, out c);
+            TestUtils.AreEqual(s, 0.3499935f, 1, false);
+            TestUtils.AreEqual(c, 0.936752141f, 8, false);
+
+            sincos(-1.2f, out s, out c);
+            TestUtils.AreEqual(s, -0.9320391f, 1, false);
+            TestUtils.AreEqual(c, 0.362357765f, 8, false);
+
+            sincos(0f, out s, out c);
+            TestUtils.AreEqual(s, 0f, 1, false);
+            TestUtils.AreEqual(c, 1f, 8, false);
+
+            sincos(1.2f, out s, out c);
+            TestUtils.AreEqual(s, 0.9320391f, 1, false);
+            TestUtils.AreEqual(c, 0.362357765f, 8, false);
+
+            sincos(1000000f, out s, out c);
+            TestUtils.AreEqual(s, -0.3499935f, 1, false);
+            TestUtils.AreEqual(c, 0.936752141f, 8, false);
+
+            sincos(float.NegativeInfinity, out s, out c);
+            TestUtils.AreEqual(s, float.NaN, 1, false);
+            TestUtils.AreEqual(c, float.NaN, 8, false);
+
+            sincos(float.NaN, out s, out c);
+            TestUtils.AreEqual(s, float.NaN, 1, false);
+            TestUtils.AreEqual(c, float.NaN, 8, false);
+
+            sincos(float.PositiveInfinity, out s, out c);
+            TestUtils.AreEqual(s, float.NaN, 1, false);
+            TestUtils.AreEqual(c, float.NaN, 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void sincos_float2()
+        {
+            float2 s, c;
+
+            sincos(float2(-1000000f, -1.2f), out s, out c);
+            TestUtils.AreEqual(s, float2(0.3499935f, -0.9320391f), 1, false);
+            TestUtils.AreEqual(c, float2(0.936752141f, 0.362357765f), 8, false);
+
+            sincos(float2(0f, 1.2f), out s, out c);
+            TestUtils.AreEqual(s, float2(0f, 0.9320391f), 1, false);
+            TestUtils.AreEqual(c, float2(1f, 0.362357765f), 8, false);
+
+            sincos(float2(1000000f, float.NegativeInfinity), out s, out c);
+            TestUtils.AreEqual(s, float2(-0.3499935f, float.NaN), 1, false);
+            TestUtils.AreEqual(c, float2(0.936752141f, float.NaN), 8, false);
+
+            sincos(float2(float.NaN, float.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(c, float2(float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_float3()
+        {
+            float3 s, c;
+
+            sincos(float3(-1000000f, -1.2f, 0f), out s, out c);
+            TestUtils.AreEqual(s, float3(0.3499935f, -0.9320391f, 0f), 1, false);
+            TestUtils.AreEqual(c, float3(0.936752141f, 0.362357765f, 1f), 8, false);
+
+            sincos(float3(1.2f, 1000000f, float.NegativeInfinity), out s, out c);
+            TestUtils.AreEqual(s, float3(0.9320391f, -0.3499935f, float.NaN), 1, false);
+            TestUtils.AreEqual(c, float3(0.362357765f, 0.936752141f, float.NaN), 8, false);
+
+            sincos(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(c, float3(float.NaN, float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_float4()
+        {
+            float4 s, c;
+
+            sincos(float4(-1000000f, -1.2f, 0f, 1.2f), out s, out c);
+            TestUtils.AreEqual(s, float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), 1, false);
+            TestUtils.AreEqual(c, float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), 8, false);
+
+            sincos(float4(1000000f, float.NegativeInfinity, float.NaN, float.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, float4(-0.3499935f, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(c, float4(0.936752141f, float.NaN, float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_double()
+        {
+            double s, c;
+            sincos(-1000000.0, out s, out c);
+            TestUtils.AreEqual(s, 0.34999350217129294, 32, false);
+            TestUtils.AreEqual(c, 0.93675212753314474, 32, false);
+
+            sincos(-1.2, out s, out c);
+            TestUtils.AreEqual(s, -0.9320390859672264, 32, false);
+            TestUtils.AreEqual(c, 0.36235775447667357, 32, false);
+
+            sincos(0.0, out s, out c);
+            TestUtils.AreEqual(s, 0.0, 32, false);
+            TestUtils.AreEqual(c, 1.0, 32, false);
+
+            sincos(1.2, out s, out c);
+            TestUtils.AreEqual(s, 0.9320390859672264, 32, false);
+            TestUtils.AreEqual(c, 0.36235775447667357, 32, false);
+
+            sincos(1000000.0, out s, out c);
+            TestUtils.AreEqual(s, -0.34999350217129294, 32, false);
+            TestUtils.AreEqual(c, 0.93675212753314474, 32, false);
+
+            sincos(double.NegativeInfinity, out s, out c);
+            TestUtils.AreEqual(s, double.NaN, 32, false);
+            TestUtils.AreEqual(c, double.NaN, 32, false);
+
+            sincos(double.NaN, out s, out c);
+            TestUtils.AreEqual(s, double.NaN, 32, false);
+            TestUtils.AreEqual(c, double.NaN, 32, false);
+
+            sincos(double.NaN, out s, out c);
+            TestUtils.AreEqual(s, double.NaN, 32, false);
+            TestUtils.AreEqual(c, double.NaN, 32, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_double2()
+        {
+            double2 s, c;
+            sincos(double2(-1000000.0, -1.2), out s, out c);
+            TestUtils.AreEqual(s, double2(0.34999350217129294, -0.9320390859672264), 32, false);
+            TestUtils.AreEqual(c, double2(0.93675212753314474, 0.36235775447667357), 32, false);
+
+            sincos(double2(0.0, 1.2), out s, out c);
+            TestUtils.AreEqual(s, double2(0.0, 0.9320390859672264), 32, false);
+            TestUtils.AreEqual(c, double2(1.0, 0.36235775447667357), 32, false);
+
+            sincos(double2(1000000.0, double.NegativeInfinity), out s, out c);
+            TestUtils.AreEqual(s, double2(-0.34999350217129294, double.NaN), 32, false);
+            TestUtils.AreEqual(c, double2(0.93675212753314474, double.NaN), 32, false);
+
+            sincos(double2(double.NaN, double.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, double2(double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(c, double2(double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_double3()
+        {
+            double3 s, c;
+
+            sincos(double3(-1000000.0, -1.2, 0.0), out s, out c);
+            TestUtils.AreEqual(s, double3(0.34999350217129294, -0.9320390859672264, 0.0), 32, false);
+            TestUtils.AreEqual(c, double3(0.93675212753314474, 0.36235775447667357, 1.0), 32, false);
+
+            sincos(double3(1.2, 1000000.0, double.NegativeInfinity), out s, out c);
+            TestUtils.AreEqual(s, double3(0.9320390859672264, -0.34999350217129294, double.NaN), 32, false);
+            TestUtils.AreEqual(c, double3(0.36235775447667357, 0.93675212753314474, double.NaN), 32, false);
+
+            sincos(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, double3(double.NaN, double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(c, double3(double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sincos_double4()
+        {
+            double4 s, c;
+
+            sincos(double4(-1000000.0, -1.2, 0.0, 1.2), out s, out c);
+            TestUtils.AreEqual(s, double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), 32, false);
+            TestUtils.AreEqual(c, double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), 32, false);
+
+            sincos(double4(1000000.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity), out s, out c);
+            TestUtils.AreEqual(s, double4(-0.34999350217129294, double.NaN, double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(c, double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void select_int()
+        {
+            TestUtils.AreEqual(select(-123456789, 987654321, false), -123456789);
+            TestUtils.AreEqual(select(-123456789, 987654321, true), 987654321);
+        }
+
+        [TestCompiler]
+        public static void select_int2()
+        {
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), false), int2(-123456789, -123456790));
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), true), int2(987654321, 987654322));
+
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(false, false)), int2(-123456789, -123456790));
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(false, true)), int2(-123456789, 987654322));
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, false)), int2(987654321, -123456790));
+            TestUtils.AreEqual(select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, true)), int2(987654321, 987654322));
+        }
+
+        [TestCompiler]
+        public static void select_int3()
+        {
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), false), int3(-123456789, -123456790, -123456791));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), true), int3(987654321, 987654322, 987654323));
+
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(false, false, false)), int3(-123456789, -123456790, -123456791));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(false, false, true)), int3(-123456789, -123456790, 987654323));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(false, true, false)), int3(-123456789, 987654322, -123456791));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(false, true, true)), int3(-123456789, 987654322, 987654323));
+
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, false, false)), int3(987654321, -123456790, -123456791));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, false, true)), int3(987654321, -123456790, 987654323));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, false)), int3(987654321, 987654322, -123456791));
+            TestUtils.AreEqual(select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, true)), int3(987654321, 987654322, 987654323));
+        }
+
+        [TestCompiler]
+        public static void select_int4()
+        {
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), false), int4(-123456789, -123456790, -123456791, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), true), int4(987654321, 987654322, 987654323, 987654324));
+
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, false, false, false)), int4(-123456789, -123456790, -123456791, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, false, false, true)), int4(-123456789, -123456790, -123456791, 987654324));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, false, true, false)), int4(-123456789, -123456790, 987654323, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, false, true, true)), int4(-123456789, -123456790, 987654323, 987654324));
+
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, true, false, false)), int4(-123456789, 987654322, -123456791, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, true, false, true)), int4(-123456789, 987654322, -123456791, 987654324));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, true, true, false)), int4(-123456789, 987654322, 987654323, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(false, true, true, true)), int4(-123456789, 987654322, 987654323, 987654324));
+
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, false, false, false)), int4(987654321, -123456790, -123456791, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, false, false, true)), int4(987654321, -123456790, -123456791, 987654324));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, false, true, false)), int4(987654321, -123456790, 987654323, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, false, true, true)), int4(987654321, -123456790, 987654323, 987654324));
+
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, false, false)), int4(987654321, 987654322, -123456791, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, false, true)), int4(987654321, 987654322, -123456791, 987654324));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, false)), int4(987654321, 987654322, 987654323, -123456792));
+            TestUtils.AreEqual(select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, true)), int4(987654321, 987654322, 987654323, 987654324));
+        }
+
+        [TestCompiler]
+        public static void select_uint()
+        {
+            TestUtils.AreEqual(select(123456789u, 987654321u, false), 123456789u);
+            TestUtils.AreEqual(select(123456789u, 987654321u, true), 987654321u);
+        }
+
+        [TestCompiler]
+        public static void select_uint2()
+        {
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), false), uint2(123456789u, 123456790u));
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), true), uint2(987654321u, 987654322));
+
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(false, false)), uint2(123456789u, 123456790u));
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(false, true)), uint2(123456789u, 987654322u));
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, false)), uint2(987654321u, 123456790u));
+            TestUtils.AreEqual(select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, true)), uint2(987654321u, 987654322u));
+        }
+
+        [TestCompiler]
+        public static void select_uint3()
+        {
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), false), uint3(123456789u, 123456790u, 123456791u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), true), uint3(987654321u, 987654322u, 987654323));
+
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(false, false, false)), uint3(123456789u, 123456790u, 123456791u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(false, false, true)), uint3(123456789u, 123456790u, 987654323u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(false, true, false)), uint3(123456789u, 987654322u, 123456791u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(false, true, true)), uint3(123456789u, 987654322u, 987654323u));
+
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, false, false)), uint3(987654321u, 123456790u, 123456791u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, false, true)), uint3(987654321u, 123456790u, 987654323u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, false)), uint3(987654321u, 987654322u, 123456791u));
+            TestUtils.AreEqual(select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, true)), uint3(987654321u, 987654322u, 987654323u));
+        }
+
+        [TestCompiler]
+        public static void select_uint4()
+        {
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), false), uint4(123456789u, 123456790u, 123456791u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), true), uint4(987654321u, 987654322u, 987654323u, 987654324u));
+
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, false, false, false)), uint4(123456789u, 123456790u, 123456791u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, false, false, true)), uint4(123456789u, 123456790u, 123456791u, 987654324u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, false, true, false)), uint4(123456789u, 123456790u, 987654323u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, false, true, true)), uint4(123456789u, 123456790u, 987654323u, 987654324u));
+
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, true, false, false)), uint4(123456789u, 987654322u, 123456791u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, true, false, true)), uint4(123456789u, 987654322u, 123456791u, 987654324u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, true, true, false)), uint4(123456789u, 987654322u, 987654323u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(false, true, true, true)), uint4(123456789u, 987654322u, 987654323u, 987654324u));
+
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, false, false, false)), uint4(987654321u, 123456790u, 123456791u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, false, false, true)), uint4(987654321u, 123456790u, 123456791u, 987654324u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, false, true, false)), uint4(987654321u, 123456790u, 987654323u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, false, true, true)), uint4(987654321u, 123456790u, 987654323u, 987654324u));
+
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, false, false)), uint4(987654321u, 987654322u, 123456791u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, false, true)), uint4(987654321u, 987654322u, 123456791u, 987654324u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, false)), uint4(987654321u, 987654322u, 987654323u, 123456792u));
+            TestUtils.AreEqual(select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, true)), uint4(987654321u, 987654322u, 987654323u, 987654324u));
+        }
+
+        [TestCompiler]
+        public static void select_long()
+        {
+            TestUtils.AreEqual(select(-12345678910111314L, 987654321011121314L, false), -12345678910111314L);
+            TestUtils.AreEqual(select(-12345678910111314L, 987654321011121314L, true), 987654321011121314L);
+        }
+
+        [TestCompiler]
+        public static void select_ulong()
+        {
+            TestUtils.AreEqual(select(12345678910111314UL, 987654321011121314UL, false), 12345678910111314UL);
+            TestUtils.AreEqual(select(12345678910111314UL, 987654321011121314UL, true), 987654321011121314UL);
+        }
+
+
+        [TestCompiler]
+        public static void select_float()
+        {
+            TestUtils.AreEqual(select(-1234.5f, 9876.25f, false), -1234.5f);
+            TestUtils.AreEqual(select(-1234.5f, 9876.25f, true), 9876.25f);
+        }
+
+        [TestCompiler]
+        public static void select_float2()
+        {
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), false), float2(-1234.5f, -1235.5f));
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), true), float2(9876.25f, 9877.25f));
+
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(false, false)), float2(-1234.5f, -1235.5f));
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(false, true)), float2(-1234.5f, 9877.25f));
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, false)), float2(9876.25f, -1235.5f));
+            TestUtils.AreEqual(select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, true)), float2(9876.25f, 9877.25f));
+        }
+
+        [TestCompiler]
+        public static void select_float3()
+        {
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), false), float3(-1234.5f, -1235.5f, -1236.5f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), true), float3(9876.25f, 9877.25f, 9878.25f));
+
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(false, false, false)), float3(-1234.5f, -1235.5f, -1236.5f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(false, false, true)), float3(-1234.5f, -1235.5f, 9878.25f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(false, true, false)), float3(-1234.5f, 9877.25f, -1236.5f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(false, true, true)), float3(-1234.5f, 9877.25f, 9878.25f));
+
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, false, false)), float3(9876.25f, -1235.5f, -1236.5f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, false, true)), float3(9876.25f, -1235.5f, 9878.25f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, false)), float3(9876.25f, 9877.25f, -1236.5f));
+            TestUtils.AreEqual(select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, true)), float3(9876.25f, 9877.25f, 9878.25f));
+        }
+
+        [TestCompiler]
+        public static void select_float4()
+        {
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), false), float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), true), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f));
+
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, false, false, false)), float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, false, false, true)), float4(-1234.5f, -1235.5f, -1236.5f, 9879.25f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, false, true, false)), float4(-1234.5f, -1235.5f, 9878.25f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, false, true, true)), float4(-1234.5f, -1235.5f, 9878.25f, 9879.25f));
+
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, true, false, false)), float4(-1234.5f, 9877.25f, -1236.5f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, true, false, true)), float4(-1234.5f, 9877.25f, -1236.5f, 9879.25f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, true, true, false)), float4(-1234.5f, 9877.25f, 9878.25f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(false, true, true, true)), float4(-1234.5f, 9877.25f, 9878.25f, 9879.25f));
+
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, false, false, false)), float4(9876.25f, -1235.5f, -1236.5f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, false, false, true)), float4(9876.25f, -1235.5f, -1236.5f, 9879.25f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, false, true, false)), float4(9876.25f, -1235.5f, 9878.25f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, false, true, true)), float4(9876.25f, -1235.5f, 9878.25f, 9879.25f));
+
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, true, false, false)), float4(9876.25f, 9877.25f, -1236.5f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, true, false, true)), float4(9876.25f, 9877.25f, -1236.5f, 9879.25f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, true, true, false)), float4(9876.25f, 9877.25f, 9878.25f, -1237.5f));
+            TestUtils.AreEqual(select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), bool4(true, true, true, true)), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f));
+        }
+
+
+        [TestCompiler]
+        public static void select_double()
+        {
+            TestUtils.AreEqual(select(-1234.5, 9876.25, false), -1234.5);
+            TestUtils.AreEqual(select(-1234.5, 9876.25, true), 9876.25);
+        }
+
+        [TestCompiler]
+        public static void select_double2()
+        {
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), false), double2(-1234.5, -1235.5));
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), true), double2(9876.25, 9877.25));
+
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(false, false)), double2(-1234.5, -1235.5));
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(false, true)), double2(-1234.5, 9877.25));
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, false)), double2(9876.25, -1235.5));
+            TestUtils.AreEqual(select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, true)), double2(9876.25, 9877.25));
+        }
+
+        [TestCompiler]
+        public static void select_double3()
+        {
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), false), double3(-1234.5, -1235.5, -1236.5));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), true), double3(9876.25, 9877.25, 9878.25));
+
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(false, false, false)), double3(-1234.5, -1235.5, -1236.5));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(false, false, true)), double3(-1234.5, -1235.5, 9878.25));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(false, true, false)), double3(-1234.5, 9877.25, -1236.5));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(false, true, true)), double3(-1234.5, 9877.25, 9878.25));
+
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, false, false)), double3(9876.25, -1235.5, -1236.5));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, false, true)), double3(9876.25, -1235.5, 9878.25));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, false)), double3(9876.25, 9877.25, -1236.5));
+            TestUtils.AreEqual(select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, true)), double3(9876.25, 9877.25, 9878.25));
+        }
+
+        [TestCompiler]
+        public static void select_double4()
+        {
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), false), double4(-1234.5, -1235.5, -1236.5, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), true), double4(9876.25, 9877.25, 9878.25, 9879.25));
+
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, false, false, false)), double4(-1234.5, -1235.5, -1236.5, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, false, false, true)), double4(-1234.5, -1235.5, -1236.5, 9879.25));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, false, true, false)), double4(-1234.5, -1235.5, 9878.25, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, false, true, true)), double4(-1234.5, -1235.5, 9878.25, 9879.25));
+
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, true, false, false)), double4(-1234.5, 9877.25, -1236.5, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, true, false, true)), double4(-1234.5, 9877.25, -1236.5, 9879.25));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, true, true, false)), double4(-1234.5, 9877.25, 9878.25, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(false, true, true, true)), double4(-1234.5, 9877.25, 9878.25, 9879.25));
+
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, false, false, false)), double4(9876.25, -1235.5, -1236.5, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, false, false, true)), double4(9876.25, -1235.5, -1236.5, 9879.25));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, false, true, false)), double4(9876.25, -1235.5, 9878.25, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, false, true, true)), double4(9876.25, -1235.5, 9878.25, 9879.25));
+
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, true, false, false)), double4(9876.25, 9877.25, -1236.5, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, true, false, true)), double4(9876.25, 9877.25, -1236.5, 9879.25));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, true, true, false)), double4(9876.25, 9877.25, 9878.25, -1237.5));
+            TestUtils.AreEqual(select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), bool4(true, true, true, true)), double4(9876.25, 9877.25, 9878.25, 9879.25));
+        }
+
+
+        [TestCompiler]
+        public static void dot_int()
+        {
+            TestUtils.AreEqual(dot(7, 19), 133);
+            TestUtils.AreEqual(dot(-7, 19), -133);
+            TestUtils.AreEqual(dot(61031, 41312), -1773654624);
+            TestUtils.AreEqual(dot(61031, 81312), 667585376);
+        }
+
+        [TestCompiler]
+        public static void dot_int2()
+        {
+            TestUtils.AreEqual(dot(int2(7, 9), int2(19, 21)), 322);
+            TestUtils.AreEqual(dot(int2(-7, 9), int2(19, -21)), -322);
+            TestUtils.AreEqual(dot(int2(61031, 12534), int2(41312, 5312)), -1707074016);
+            TestUtils.AreEqual(dot(int2(61031, -12534), int2(-41312, -5312)), 1840235232);
+        }
+
+        [TestCompiler]
+        public static void dot_int3()
+        {
+            TestUtils.AreEqual(dot(int3(7, 9, 13), int3(19, 21, 20)), 582);
+            TestUtils.AreEqual(dot(int3(-7, 9, 13), int3(19, -21, -20)), -582);
+            TestUtils.AreEqual(dot(int3(61031, 12534, 9211), int3(41312, 5312, 22123)), -1503299063);
+            TestUtils.AreEqual(dot(int3(61031, -12534, 9211), int3(-41312, -5312, -22123)), 1636460279);
+        }
+
+        [TestCompiler]
+        public static void dot_int4()
+        {
+            TestUtils.AreEqual(dot(int4(7, 9, 13, 17), int4(19, 21, 20, 24)), 990);
+            TestUtils.AreEqual(dot(int4(-7, 9, 13, -17), int4(19, -21, -20, 24)), -990);
+            TestUtils.AreEqual(dot(int4(61031, 12534, 9211, 33122), int4(41312, 5312, 22123, 65423)), 663641543);
+            TestUtils.AreEqual(dot(int4(61031, -12534, 9211, 33122), int4(-41312, -5312, -22123, 65423)), -491566411);
+        }
+
+
+        [TestCompiler]
+        public static void dot_uint()
+        {
+            TestUtils.AreEqual(dot(7u, 19u), 133u);
+            TestUtils.AreEqual(dot(61031u, 81312u), 667585376u);
+        }
+
+        [TestCompiler]
+        public static void dot_uint2()
+        {
+            TestUtils.AreEqual(dot(uint2(7u, 9u), uint2(19u, 21u)), 322);
+            TestUtils.AreEqual(dot(uint2(61031u, 12534u), uint2(81312u, 5312u)), 734165984u);
+        }
+
+        [TestCompiler]
+        public static void dot_uint3()
+        {
+            TestUtils.AreEqual(dot(uint3(7u, 9u, 13u), uint3(19u, 21u, 20u)), 582u);
+            TestUtils.AreEqual(dot(uint3(61031u, 12534u, 9211u), uint3(81312u, 5312u, 22123u)), 937940937u);
+        }
+
+        [TestCompiler]
+        public static void dot_uint4()
+        {
+            TestUtils.AreEqual(dot(uint4(7u, 9u, 13u, 17u), uint4(19u, 21u, 20u, 24u)), 990u);
+            TestUtils.AreEqual(dot(uint4(61031u, 12534u, 9211u, 33122u), uint4(81312u, 5312u, 22123u, 65423u)), 3104881543u);
+        }
+
+
+        [TestCompiler]
+        public static void dot_float()
+        {
+            TestUtils.AreEqual(dot(1.2f, 6.1f), 7.32f, 1, false);
+            TestUtils.AreEqual(dot(1.2f, -6.1f), -7.32f, 1, false);
+            TestUtils.AreEqual(dot(1.2e19f, 6.1e18f), 7.32e37f, 1, false);
+            TestUtils.AreEqual(dot(-1.2e19f, 6.1e18f), -7.32e37f, 1, false);
+            TestUtils.AreEqual(dot(1.2e19f, 6.1e19f), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(dot(1.2e19f, -6.1e19f), float.NegativeInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void dot_float2()
+        {
+            TestUtils.AreEqual(dot(float2(1.2f, 5.5f), float2(6.1f, 9.2f)), 57.92f, 1, false);
+            TestUtils.AreEqual(dot(float2(-1.2f, 5.5f), float2(6.1f, -9.2f)), -57.92f, 1, false);
+            TestUtils.AreEqual(dot(float2(1.2e18f, 5.5e18f), float2(6.1e18f, 9.2e18f)), 5.792e37f, 1, false);
+            TestUtils.AreEqual(dot(float2(-1.2e18f, 5.5e18f), float2(6.1e18f, -9.2e18f)), -5.792e37f, 1, false);
+            TestUtils.AreEqual(dot(float2(1.2e18f, 5.5e18f), float2(6.1e19f, 9.2e19f)), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(float2(-1.2e18f, 5.5e18f), float2(6.1e19f, -9.2e19f)), float.NegativeInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void dot_float3()
+        {
+            TestUtils.AreEqual(dot(float3(1.2f, 5.5f, 3.4f), float3(6.1f, 9.2f, 2.7f)), 67.1f, 8, false);
+            TestUtils.AreEqual(dot(float3(-1.2f, 5.5f, -3.4f), float3(6.1f, -9.2f, 2.7f)), -67.1f, 8, false);
+            TestUtils.AreEqual(dot(float3(1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e18f, 9.2e18f, 2.7e18f)), 6.71e37f, 1, false);
+            TestUtils.AreEqual(dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e18f, -9.2e18f, -2.7e18f)), -6.71e37f, 1, false);
+            TestUtils.AreEqual(dot(float3(1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, 9.2e19f, 2.7e19f)), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, -9.2e19f, -2.7e19f)), float.NegativeInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void dot_float4()
+        {
+            TestUtils.AreEqual(dot(float4(1.2f, 5.5f, 3.4f, 4.9f), float4(6.1f, 9.2f, 2.7f, 0.3f)), 68.57f, 8, false);
+            TestUtils.AreEqual(dot(float4(-1.2f, 5.5f, -3.4f, 4.9f), float4(6.1f, -9.2f, 2.7f, -0.3f)), -68.57f, 8, false);
+            TestUtils.AreEqual(dot(float4(1.2e18f, 5.5e18f, 3.4e18f, 4.9e18f), float4(6.1e18f, 9.2e18f, 2.7e18f, 3e17f)), 6.857e37f, 1, false);
+            TestUtils.AreEqual(dot(float4(-1.2e18f, 5.5e18f, 3.4e18f, -4.9e18f), float4(6.1e18f, -9.2e18f, -2.7e18f, 3e17f)), -6.857e37f, 1, false);
+            TestUtils.AreEqual(dot(float4(1.2e18f, 5.5e18f, 3.4e18f, 4.9e18f), float4(6.1e19f, 9.2e19f, 2.7e19f, 3e18f)), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(float4(-1.2e18f, 5.5e18f, 3.4e18f, -4.9e18f), float4(6.1e19f, -9.2e19f, -2.7e19f, 3e18f)), float.NegativeInfinity, 1, false);
+        }
+
+
+        public static void dot_double()
+        {
+            TestUtils.AreEqual(dot(1.2, 6.1), 7.32, 1, false);
+            TestUtils.AreEqual(dot(1.2, -6.1), -7.32, 1, false);
+            TestUtils.AreEqual(dot(1.2e19, 6.1e18), 7.32e37, 1, false);
+            TestUtils.AreEqual(dot(-1.2e19, 6.1e18), -7.32e37, 1, false);
+            TestUtils.AreEqual(dot(1.2e19, 6.1e19), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(dot(1.2e19, -6.1e19), double.NegativeInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void dot_double2()
+        {
+            TestUtils.AreEqual(dot(double2(1.2, 5.5), double2(6.1, 9.2)), 57.92, 1, false);
+            TestUtils.AreEqual(dot(double2(-1.2, 5.5), double2(6.1, -9.2)), -57.92, 1, false);
+            TestUtils.AreEqual(dot(double2(1.2e153, 5.5e153), double2(6.1e153, 9.2e153)), 5.792e307, 1, false);
+            TestUtils.AreEqual(dot(double2(-1.2e153, 5.5e153), double2(6.1e153, -9.2e153)), -5.792e307, 1, false);
+            TestUtils.AreEqual(dot(double2(1.2e153, 5.5e153), double2(6.1e154, 9.2e154)), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(double2(-1.2e153, 5.5e153), double2(6.1e154, -9.2e154)), double.NegativeInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void dot_double3()
+        {
+            TestUtils.AreEqual(dot(double3(1.2, 5.5, 3.4), double3(6.1, 9.2, 2.7)), 67.1, 8, false);
+            TestUtils.AreEqual(dot(double3(-1.2, 5.5, -3.4), double3(6.1, -9.2, 2.7)), -67.1, 8, false);
+            TestUtils.AreEqual(dot(double3(1.2e153, 5.5e153, 3.4e153), double3(6.1e153, 9.2e153, 2.7e153)), 6.71e307, 1, false);
+            TestUtils.AreEqual(dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e153, -9.2e153, -2.7e153)), -6.71e307, 1, false);
+            TestUtils.AreEqual(dot(double3(1.2e153, 5.5e153, 3.4e153), double3(6.1e154, 9.2e154, 2.7e154)), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e154, -9.2e154, -2.7e154)), double.NegativeInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void dot_double4()
+        {
+            TestUtils.AreEqual(dot(double4(1.2, 5.5, 3.4, 4.9), double4(6.1, 9.2, 2.7, 0.3)), 68.57, 8, false);
+            TestUtils.AreEqual(dot(double4(-1.2, 5.5, -3.4, 4.9), double4(6.1, -9.2, 2.7, -0.3)), -68.57, 8, false);
+            TestUtils.AreEqual(dot(double4(1.2e153, 5.5e153, 3.4e153, 4.9e153), double4(6.1e153, 9.2e153, 2.7e153, 3e152)), 6.857e307, 1, false);
+            TestUtils.AreEqual(dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e153, -9.2e153, -2.7e153, 3e152)), -6.857e307, 1, false);
+            TestUtils.AreEqual(dot(double4(1.2e153, 5.5e153, 3.4e153, 4.9e153), double4(6.1e154, 9.2e154, 2.7e154, 3e153)), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e154, -9.2e154, -2.7e154, 3e153)), double.NegativeInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void cmin_int2()
+        {
+            TestUtils.AreEqual(cmin(int2(100, 200)), 100);
+            TestUtils.AreEqual(cmin(int2(100, -200)), -200);
+            TestUtils.AreEqual(cmin(int2(int.MaxValue, 0)), 0);
+            TestUtils.AreEqual(cmin(int2(int.MinValue, 0)), int.MinValue);
+            TestUtils.AreEqual(cmin(int2(int.MaxValue, int.MinValue)), int.MinValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmin_int3()
+        {
+            TestUtils.AreEqual(cmin(int3(100, 200, 300)), 100);
+            TestUtils.AreEqual(cmin(int3(100, -200, 300)), -200);
+            TestUtils.AreEqual(cmin(int3(int.MaxValue, 0, 7)), 0);
+            TestUtils.AreEqual(cmin(int3(int.MinValue, 0, 7)), int.MinValue);
+            TestUtils.AreEqual(cmin(int3(int.MaxValue, int.MinValue, 0)), int.MinValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmin_int4()
+        {
+            TestUtils.AreEqual(cmin(int4(100, 200, 300, 400)), 100);
+            TestUtils.AreEqual(cmin(int4(100, -200, 300, -400)), -400);
+            TestUtils.AreEqual(cmin(int4(int.MaxValue, 0, 7, 19)), 0);
+            TestUtils.AreEqual(cmin(int4(int.MinValue, 0, 7, 19)), int.MinValue);
+            TestUtils.AreEqual(cmin(int4(int.MaxValue, int.MinValue, 0, 19)), int.MinValue);
+        }
+
+        [TestCompiler]
+        public static void cmin_uint2()
+        {
+            TestUtils.AreEqual(cmin(uint2(100u, 200u)), 100u);
+            TestUtils.AreEqual(cmin(uint2(100u, uint.MaxValue)), 100u);
+            TestUtils.AreEqual(cmin(uint2(uint.MinValue, uint.MaxValue)), uint.MinValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmin_uint3()
+        {
+            TestUtils.AreEqual(cmin(uint3(100u, 200u, 300u)), 100u);
+            TestUtils.AreEqual(cmin(uint3(uint.MaxValue, 100u, 300u)), 100u);
+            TestUtils.AreEqual(cmin(uint3(7u, uint.MinValue, uint.MaxValue)), uint.MinValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmin_uint4()
+        {
+            TestUtils.AreEqual(cmin(uint4(100u, 200u, 300u, 400u)), 100u);
+            TestUtils.AreEqual(cmin(uint4(300u, 100u, uint.MaxValue, 200u)), 100u);
+            TestUtils.AreEqual(cmin(uint4(19u, uint.MinValue, uint.MaxValue, 7u)), uint.MinValue);
+        }
+
+        [TestCompiler]
+        public static void cmin_float2()
+        {
+            TestUtils.AreEqual(cmin(float2(5.2f, -0.5f)), -0.5f);
+            TestUtils.AreEqual(cmin(float2(float.NegativeInfinity, float.PositiveInfinity)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float2(float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float2(float.NegativeInfinity, 100.0f)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float2(float.PositiveInfinity, 100.0f)), 100.0f);
+
+            TestUtils.AreEqual(cmin(float2(1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float2(float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmin(float2(float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float2(float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(float2(float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float2(float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmin_float3()
+        {
+            TestUtils.AreEqual(cmin(float3(5.2f, -0.5f, -1.2f)), -1.2f);
+            TestUtils.AreEqual(cmin(float3(float.NegativeInfinity, float.PositiveInfinity, 100.0f)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float3(float.NegativeInfinity, float.NaN, 100.0f)), float.NegativeInfinity);
+
+            TestUtils.AreEqual(cmin(float3(1.0f, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float3(float.NaN, 1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float3(float.NaN, float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmin(float3(float.PositiveInfinity, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float3(float.NaN, float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float3(float.NaN, float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(float3(float.NegativeInfinity, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float3(float.NaN, float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float3(float.NaN, float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmin_float4()
+        {
+            TestUtils.AreEqual(cmin(float4(5.2f, -0.5f, -1.2f, 2.3f)), -1.2f);
+            TestUtils.AreEqual(cmin(float4(float.NegativeInfinity, float.PositiveInfinity, 100.0f, float.NaN)), float.NegativeInfinity);
+
+            TestUtils.AreEqual(cmin(float4(1.0f, float.NaN, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float4(float.NaN, 1.0f, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, 1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmin(float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.PositiveInfinity, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(float4(float.NegativeInfinity, float.NaN, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NegativeInfinity, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmin(float4(float.NaN, float.NaN, float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+
+        [TestCompiler]
+        public static void cmin_double2()
+        {
+            TestUtils.AreEqual(cmin(double2(5.2, -0.5)), -0.5);
+            TestUtils.AreEqual(cmin(double2(5.2e100, -0.5e100)), -0.5e100);
+            TestUtils.AreEqual(cmin(double2(double.NegativeInfinity, double.PositiveInfinity)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double2(double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double2(double.NegativeInfinity, 100.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double2(double.PositiveInfinity, 100.0)), 100.0);
+
+            TestUtils.AreEqual(cmin(double2(1.0, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmin(double2(double.NaN, 1.0)), 1.0);
+
+            TestUtils.AreEqual(cmin(double2(double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double2(double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(double2(double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double2(double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmin_double3()
+        {
+            TestUtils.AreEqual(cmin(double3(5.2, -0.5, -1.2)), -1.2);
+            TestUtils.AreEqual(cmin(double3(5.2e100, -0.5e100, -1.2e100)), -1.2e100);
+            TestUtils.AreEqual(cmin(double3(double.NegativeInfinity, double.PositiveInfinity, 100.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double3(double.NegativeInfinity, double.NaN, 100.0)), double.NegativeInfinity);
+
+            TestUtils.AreEqual(cmin(double3(1.0, double.NaN, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmin(double3(double.NaN, 1.0, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmin(double3(double.NaN, double.NaN, 1.0)), 1.0);
+
+            TestUtils.AreEqual(cmin(double3(double.PositiveInfinity, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double3(double.NaN, double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double3(double.NaN, double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(double3(double.NegativeInfinity, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double3(double.NaN, double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double3(double.NaN, double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmin_double4()
+        {
+            TestUtils.AreEqual(cmin(double4(5.2, -0.5, -1.2, 2.3)), -1.2);
+            TestUtils.AreEqual(cmin(double4(5.2e100, -0.5e100, -1.2e100, 2.3e100)), -1.2e100);
+
+            TestUtils.AreEqual(cmin(double4(double.NegativeInfinity, double.PositiveInfinity, 100.0, double.NaN)), double.NegativeInfinity);
+
+            TestUtils.AreEqual(cmin(double4(1.0, double.NaN, double.NaN, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmin(double4(double.NaN, 1.0, double.NaN, double.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, 1.0, double.NaN)), 1.0f);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, double.NaN, 1.0)), 1.0f);
+
+            TestUtils.AreEqual(cmin(double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.PositiveInfinity, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmin(double4(double.NegativeInfinity, double.NaN, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NegativeInfinity, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmin(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_int2()
+        {
+            TestUtils.AreEqual(cmax(int2(100, 200)), 200);
+            TestUtils.AreEqual(cmax(int2(100, -200)), 100);
+            TestUtils.AreEqual(cmax(int2(int.MaxValue, 0)), int.MaxValue);
+            TestUtils.AreEqual(cmax(int2(int.MinValue, 0)), 0);
+            TestUtils.AreEqual(cmax(int2(int.MaxValue, int.MinValue)), int.MaxValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_int3()
+        {
+            TestUtils.AreEqual(cmax(int3(100, 200, 300)), 300);
+            TestUtils.AreEqual(cmax(int3(100, -200, 300)), 300);
+            TestUtils.AreEqual(cmax(int3(int.MaxValue, 0, 7)), int.MaxValue);
+            TestUtils.AreEqual(cmax(int3(int.MinValue, 0, 7)), 7);
+            TestUtils.AreEqual(cmax(int3(int.MaxValue, int.MinValue, 0)), int.MaxValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_int4()
+        {
+            TestUtils.AreEqual(cmax(int4(100, 200, 300, 400)), 400);
+            TestUtils.AreEqual(cmax(int4(100, -200, 300, -400)), 300);
+            TestUtils.AreEqual(cmax(int4(int.MaxValue, 0, 7, 19)), int.MaxValue);
+            TestUtils.AreEqual(cmax(int4(int.MinValue, 0, 7, 19)), 19);
+            TestUtils.AreEqual(cmax(int4(int.MaxValue, int.MinValue, 0, 19)), int.MaxValue);
+        }
+
+        [TestCompiler]
+        public static void cmax_uint2()
+        {
+            TestUtils.AreEqual(cmax(uint2(100u, 200u)), 200u);
+            TestUtils.AreEqual(cmax(uint2(100u, uint.MaxValue)), uint.MaxValue);
+            TestUtils.AreEqual(cmax(uint2(uint.MinValue, uint.MaxValue)), uint.MaxValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_uint3()
+        {
+            TestUtils.AreEqual(cmax(uint3(100u, 200u, 300u)), 300u);
+            TestUtils.AreEqual(cmax(uint3(uint.MaxValue, 100u, 300u)), uint.MaxValue);
+            TestUtils.AreEqual(cmax(uint3(7u, uint.MinValue, uint.MaxValue)), uint.MaxValue);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_uint4()
+        {
+            TestUtils.AreEqual(cmax(uint4(100u, 200u, 300u, 400u)), 400u);
+            TestUtils.AreEqual(cmax(uint4(300u, 100u, uint.MaxValue, 200u)), uint.MaxValue);
+            TestUtils.AreEqual(cmax(uint4(19u, uint.MinValue, uint.MaxValue, 7u)), uint.MaxValue);
+        }
+
+        [TestCompiler]
+        public static void cmax_float2()
+        {
+            TestUtils.AreEqual(cmax(float2(5.2f, -0.5f)), 5.2f);
+            TestUtils.AreEqual(cmax(float2(float.NegativeInfinity, float.PositiveInfinity)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float2(float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float2(float.NegativeInfinity, 100.0f)), 100.0f);
+            TestUtils.AreEqual(cmax(float2(float.PositiveInfinity, 100.0f)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(float2(1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float2(float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmax(float2(float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float2(float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(float2(float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float2(float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmax_float3()
+        {
+            TestUtils.AreEqual(cmax(float3(5.2f, -0.5f, -1.2f)), 5.2f);
+            TestUtils.AreEqual(cmax(float3(float.NegativeInfinity, float.PositiveInfinity, 100.0f)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float3(float.NegativeInfinity, float.NaN, 100.0f)), 100.0f);
+
+            TestUtils.AreEqual(cmax(float3(1.0f, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float3(float.NaN, 1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float3(float.NaN, float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmax(float3(float.PositiveInfinity, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float3(float.NaN, float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float3(float.NaN, float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(float3(float.NegativeInfinity, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float3(float.NaN, float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float3(float.NaN, float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmax_float4()
+        {
+            TestUtils.AreEqual(cmax(float4(5.2f, -0.5f, -1.2f, 2.3f)), 5.2f);
+            TestUtils.AreEqual(cmax(float4(float.NegativeInfinity, float.PositiveInfinity, 100.0f, float.NaN)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(float4(1.0f, float.NaN, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float4(float.NaN, 1.0f, float.NaN, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, 1.0f, float.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, float.NaN, 1.0f)), 1.0f);
+
+            TestUtils.AreEqual(cmax(float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.PositiveInfinity, float.NaN, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, float.PositiveInfinity, float.NaN)), float.PositiveInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, float.NaN, float.PositiveInfinity)), float.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(float4(float.NegativeInfinity, float.NaN, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NegativeInfinity, float.NaN, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, float.NegativeInfinity, float.NaN)), float.NegativeInfinity);
+            TestUtils.AreEqual(cmax(float4(float.NaN, float.NaN, float.NaN, float.NegativeInfinity)), float.NegativeInfinity);
+        }
+
+
+        [TestCompiler]
+        public static void cmax_double2()
+        {
+            TestUtils.AreEqual(cmax(double2(5.2, -0.5)), 5.2);
+            TestUtils.AreEqual(cmax(double2(5.2e100, -0.5e100)), 5.2e100);
+            TestUtils.AreEqual(cmax(double2(double.NegativeInfinity, double.PositiveInfinity)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double2(double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double2(double.NegativeInfinity, 100.0)), 100.0);
+            TestUtils.AreEqual(cmax(double2(double.PositiveInfinity, 100.0)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(double2(1.0, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmax(double2(double.NaN, 1.0)), 1.0);
+
+            TestUtils.AreEqual(cmax(double2(double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double2(double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(double2(double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double2(double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmax_double3()
+        {
+            TestUtils.AreEqual(cmax(double3(5.2, -0.5, -1.2)), 5.2);
+            TestUtils.AreEqual(cmax(double3(5.2e100, -0.5e100, -1.2e100)), 5.2e100);
+            TestUtils.AreEqual(cmax(double3(double.NegativeInfinity, double.PositiveInfinity, 100.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double3(double.NegativeInfinity, double.NaN, 100.0)), 100.0);
+
+            TestUtils.AreEqual(cmax(double3(1.0, double.NaN, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmax(double3(double.NaN, 1.0, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmax(double3(double.NaN, double.NaN, 1.0)), 1.0);
+
+            TestUtils.AreEqual(cmax(double3(double.PositiveInfinity, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double3(double.NaN, double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double3(double.NaN, double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(double3(double.NegativeInfinity, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double3(double.NaN, double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double3(double.NaN, double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void cmax_double4()
+        {
+            TestUtils.AreEqual(cmax(double4(5.2, -0.5, -1.2, 2.3)), 5.2);
+            TestUtils.AreEqual(cmax(double4(5.2e100, -0.5e100, -1.2e100, 2.3e100)), 5.2e100);
+
+            TestUtils.AreEqual(cmax(double4(double.NegativeInfinity, double.PositiveInfinity, 100.0, double.NaN)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(double4(1.0, double.NaN, double.NaN, double.NaN)), 1.0);
+            TestUtils.AreEqual(cmax(double4(double.NaN, 1.0, double.NaN, double.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, 1.0, double.NaN)), 1.0f);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, double.NaN, 1.0)), 1.0f);
+
+            TestUtils.AreEqual(cmax(double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.PositiveInfinity, double.NaN, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, double.PositiveInfinity, double.NaN)), double.PositiveInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, double.NaN, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(cmax(double4(double.NegativeInfinity, double.NaN, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NegativeInfinity, double.NaN, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, double.NegativeInfinity, double.NaN)), double.NegativeInfinity);
+            TestUtils.AreEqual(cmax(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void csum_int2()
+        {
+            TestUtils.AreEqual(csum(int2(100, 200)), 300);
+            TestUtils.AreEqual(csum(int2(100, -200)), -100);
+            TestUtils.AreEqual(csum(int2(int.MaxValue, 7)), int.MinValue + 6);
+            TestUtils.AreEqual(csum(int2(int.MinValue, -7)), int.MaxValue - 6);
+            TestUtils.AreEqual(csum(int2(int.MaxValue, int.MinValue)), -1);
+        }
+
+
+        [TestCompiler]
+        public static void csum_int3()
+        {
+            TestUtils.AreEqual(csum(int3(100, 200, 300)), 600);
+            TestUtils.AreEqual(csum(int3(100, -200, -300)), -400);
+            TestUtils.AreEqual(csum(int3(int.MaxValue, 7, 11)), int.MinValue + 17);
+            TestUtils.AreEqual(csum(int3(int.MinValue, -7, -11)), int.MaxValue - 17);
+            TestUtils.AreEqual(csum(int3(int.MaxValue, int.MinValue, 0)), -1);
+        }
+
+
+        [TestCompiler]
+        public static void csum_int4()
+        {
+            TestUtils.AreEqual(csum(int4(100, 200, 300, 400)), 1000);
+            TestUtils.AreEqual(csum(int4(100, -200, 300, -400)), -200);
+            TestUtils.AreEqual(csum(int4(int.MaxValue, 7, 11, 19)), int.MinValue + 36);
+            TestUtils.AreEqual(csum(int4(int.MinValue, -7, -11, -19)), int.MaxValue - 36);
+            TestUtils.AreEqual(csum(int4(int.MaxValue, int.MinValue, 0, 0)), -1);
+        }
+
+        [TestCompiler]
+        public static void csum_uint2()
+        {
+            TestUtils.AreEqual(csum(uint2(100u, 200u)), 300u);
+            TestUtils.AreEqual(csum(uint2(uint.MaxValue, 7u)), 6u);
+        }
+
+
+        [TestCompiler]
+        public static void csum_uint3()
+        {
+            TestUtils.AreEqual(csum(uint3(100u, 200u, 300u)), 600u);
+            TestUtils.AreEqual(csum(uint3(uint.MaxValue, 7u, 19u)), 25u);
+        }
+
+
+        [TestCompiler]
+        public static void csum_uint4()
+        {
+            TestUtils.AreEqual(csum(uint4(100u, 200u, 300u, 400u)), 1000u);
+            TestUtils.AreEqual(csum(uint4(uint.MaxValue, 7u, 11u, 19u)), 36u);
+        }
+
+        [TestCompiler]
+        public static void csum_float2()
+        {
+            TestUtils.AreEqual(csum(float2(2.2f, -1.5f)), 0.7f, 4, false);
+            TestUtils.AreEqual(csum(float2(-2.2e38f, 1.5e38f)), -7e37f, 4, false);
+            TestUtils.AreEqual(csum(float2(-2.2e38f, -1.5e38f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float2( 2.2e38f, 1.5e38f)), float.PositiveInfinity, 0, false);
+            
+            TestUtils.AreEqual(csum(float2(float.NegativeInfinity, float.PositiveInfinity)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float2(float.NegativeInfinity, float.NaN)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float2(float.NegativeInfinity, 100.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float2(float.PositiveInfinity, 100.0f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float2(1.0f, float.NaN)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float2(float.NaN, 1.0f)), float.NaN, 0, false);
+
+            TestUtils.AreEqual(csum(float2(float.PositiveInfinity,  1.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float2(-1.0f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float2(float.NegativeInfinity, 1.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float2(-1.0f, float.NegativeInfinity)), float.NegativeInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void csum_float3()
+        {
+            TestUtils.AreEqual(csum(float3(2.2f, -1.5f, 1.2f)), 1.9f, 4, false);
+            TestUtils.AreEqual(csum(float3(2.2e38f, -1.5e38f, 1.2e38f)), 1.9e38f, 4, false);
+            TestUtils.AreEqual(csum(float3(-2.2e38f, -1.5e38f, -1.2e38f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float3(2.2e38f, 1.5e38f, 1.2e38f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float3(float.NegativeInfinity, float.PositiveInfinity, 100.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float3(float.NegativeInfinity, float.NaN, 100.0f)), float.NaN, 0, false);
+
+            TestUtils.AreEqual(csum(float3(float.NaN, 1.0f, 1.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float3(1.0f, float.NaN, 1.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float3(1.0f, 1.0f, float.NaN)), float.NaN, 0, false);
+
+            TestUtils.AreEqual(csum(float3(float.PositiveInfinity, 1.0f, -2.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float3(1.0f, float.PositiveInfinity, -2.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float3(-2.0f, 1.0f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float3(float.NegativeInfinity, 1.0f, -2.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float3(-1.0f, float.NegativeInfinity, 2.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float3(-2.0f, 1.0f, float.NegativeInfinity)), float.NegativeInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void csum_float4()
+        {
+            TestUtils.AreEqual(csum(float4(2.2f, -1.5f, 1.2f, -0.7f)), 1.2f, 4, false);
+            TestUtils.AreEqual(csum(float4(2.2e38f, -1.5e38f, 1.2e38f, -0.7e38f)), 1.2e38f, 4, false);
+            TestUtils.AreEqual(csum(float4(-2.2e38f, -1.5e38f, -1.2e38f, -0.7e38f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(2.2e38f, 1.5e38f, 1.2e38f, 0.7e38f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float4(float.NegativeInfinity, float.PositiveInfinity, 100.0f, 200.0f)), float.NaN, 0, false);
+
+            TestUtils.AreEqual(csum(float4(float.NaN, 1.0f, 1.0f, 1.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, float.NaN, 1.0f, 1.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, 1.0f, float.NaN, 1.0f)), float.NaN, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, 1.0f, 1.0f, float.NaN)), float.NaN, 0, false);
+
+            TestUtils.AreEqual(csum(float4(float.PositiveInfinity, 1.0f, -2.0f, 3.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, float.PositiveInfinity, -2.0f, 3.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, -2.0f, float.PositiveInfinity, 3.0f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, -2.0f, 3.0f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(csum(float4(float.NegativeInfinity, 1.0f, -2.0f, 3.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, float.NegativeInfinity, -2.0f, 3.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, -2.0f, float.NegativeInfinity, 3.0f)), float.NegativeInfinity, 0, false);
+            TestUtils.AreEqual(csum(float4(1.0f, -2.0f, -3.0f, float.NegativeInfinity)), float.NegativeInfinity, 0, false);
+        }
+
+
+        [TestCompiler]
+        public static void csum_double2()
+        {
+            TestUtils.AreEqual(csum(double2(2.2, -1.5)), 0.7, 4, false);
+            TestUtils.AreEqual(csum(double2(-2.2e307, 1.5e307)), -7e306, 4, false);
+            TestUtils.AreEqual(csum(double2(-1.2e308, -0.7e308)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double2(1.2e308, 0.7e308)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double2(double.NegativeInfinity, double.PositiveInfinity)), double.NaN);
+            TestUtils.AreEqual(csum(double2(double.NegativeInfinity, double.NaN)), double.NaN);
+            TestUtils.AreEqual(csum(double2(double.NegativeInfinity, 100.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double2(double.PositiveInfinity, 100.0)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double2(1.0, double.NaN)), double.NaN);
+            TestUtils.AreEqual(csum(double2(double.NaN, 1.0)), double.NaN);
+
+            TestUtils.AreEqual(csum(double2(double.PositiveInfinity, 1.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double2(-1.0, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double2(double.NegativeInfinity, 1.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double2(-1.0, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void csum_double3()
+        {
+            TestUtils.AreEqual(csum(double3(2.2, -1.5, 1.2)), 1.9, 4, false);
+            TestUtils.AreEqual(csum(double3(2.2e307, -1.5e307, 1.2e307)), 1.9e307, 4, false);
+            TestUtils.AreEqual(csum(double3(-1.2e308, -0.7e308, -1.4e308)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double3(1.2e308, 0.7e308, 1.4e308)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double3(double.NegativeInfinity, double.PositiveInfinity, 100.0)), double.NaN);
+            TestUtils.AreEqual(csum(double3(double.NegativeInfinity, double.NaN, 100.0)), double.NaN);
+
+            TestUtils.AreEqual(csum(double3(double.NaN, 1.0, 1.0)), double.NaN);
+            TestUtils.AreEqual(csum(double3(1.0, double.NaN, 1.0)), double.NaN);
+            TestUtils.AreEqual(csum(double3(1.0, 1.0, double.NaN)), double.NaN);
+
+            TestUtils.AreEqual(csum(double3(double.PositiveInfinity, 1.0, -2.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double3(1.0, double.PositiveInfinity, -2.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double3(-2.0, 1.0, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double3(double.NegativeInfinity, 1.0, -2.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double3(-1.0, double.NegativeInfinity, 2.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double3(-2.0, 1.0, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+        [TestCompiler]
+        public static void csum_double4()
+        {
+            TestUtils.AreEqual(csum(double4(2.2, -1.5, 1.2, -0.7)), 1.2, 4, false);
+            TestUtils.AreEqual(csum(double4(2.2e307, -1.5e307, 1.2e307, -0.7e307)), 1.2e307, 4, false);
+            TestUtils.AreEqual(csum(double4(-1.2e308, -0.7e308, -1.4e308, -0.9e308)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double4(1.2e308, 0.7e308, 1.4e308, 0.9e308)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double4(double.NegativeInfinity, double.PositiveInfinity, 100.0, 200.0)), double.NaN);
+
+            TestUtils.AreEqual(csum(double4(double.NaN, 1.0, 1.0, 1.0)), double.NaN);
+            TestUtils.AreEqual(csum(double4(1.0, double.NaN, 1.0, 1.0)), double.NaN);
+            TestUtils.AreEqual(csum(double4(1.0, 1.0, double.NaN, 1.0)), double.NaN);
+            TestUtils.AreEqual(csum(double4(1.0, 1.0, 1.0, double.NaN)), double.NaN);
+
+            TestUtils.AreEqual(csum(double4(double.PositiveInfinity, 1.0, -2.0, 3.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, double.PositiveInfinity, -2.0, 3.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, -2.0, double.PositiveInfinity, 3.0)), double.PositiveInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, -2.0, 3.0, double.PositiveInfinity)), double.PositiveInfinity);
+
+            TestUtils.AreEqual(csum(double4(double.NegativeInfinity, 1.0, -2.0, 3.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, double.NegativeInfinity, -2.0, 3.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, -2.0, double.NegativeInfinity, 3.0)), double.NegativeInfinity);
+            TestUtils.AreEqual(csum(double4(1.0, -2.0, 3.0, double.NegativeInfinity)), double.NegativeInfinity);
+        }
+
+
+        [TestCompiler]
+        public static void any_bool2()
+        {
+            TestUtils.AreEqual(any(bool2(false, false)), false);
+            TestUtils.AreEqual(any(bool2(false, true)), true);
+            TestUtils.AreEqual(any(bool2(true, false)), true);
+            TestUtils.AreEqual(any(bool2(true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void any_bool3()
+        {
+            TestUtils.AreEqual(any(bool3(false, false, false)), false);
+            TestUtils.AreEqual(any(bool3(false, false, true)), true);
+            TestUtils.AreEqual(any(bool3(false, true, false)), true);
+            TestUtils.AreEqual(any(bool3(false, true, true)), true);
+
+            TestUtils.AreEqual(any(bool3(true, false, false)), true);
+            TestUtils.AreEqual(any(bool3(true, false, true)), true);
+            TestUtils.AreEqual(any(bool3(true, true, false)), true);
+            TestUtils.AreEqual(any(bool3(true, true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void any_bool4()
+        {
+            TestUtils.AreEqual(any(bool4(false, false, false, false)), false);
+            TestUtils.AreEqual(any(bool4(false, false, false, true)), true);
+            TestUtils.AreEqual(any(bool4(false, false, true, false)), true);
+            TestUtils.AreEqual(any(bool4(false, false, true, true)), true);
+
+            TestUtils.AreEqual(any(bool4(false, true, false, false)), true);
+            TestUtils.AreEqual(any(bool4(false, true, false, true)), true);
+            TestUtils.AreEqual(any(bool4(false, true, true, false)), true);
+            TestUtils.AreEqual(any(bool4(false, true, true, true)), true);
+
+            TestUtils.AreEqual(any(bool4(true, false, false, false)), true);
+            TestUtils.AreEqual(any(bool4(true, false, false, true)), true);
+            TestUtils.AreEqual(any(bool4(true, false, true, false)), true);
+            TestUtils.AreEqual(any(bool4(true, false, true, true)), true);
+
+            TestUtils.AreEqual(any(bool4(true, true, false, false)), true);
+            TestUtils.AreEqual(any(bool4(true, true, false, true)), true);
+            TestUtils.AreEqual(any(bool4(true, true, true, false)), true);
+            TestUtils.AreEqual(any(bool4(true, true, true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void any_int2()
+        {
+            TestUtils.AreEqual(any(int2(0, 0)), false);
+            TestUtils.AreEqual(any(int2(0, -1)), true);
+            TestUtils.AreEqual(any(int2(1, 0)), true);
+            TestUtils.AreEqual(any(int2(2, int.MinValue)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_int3()
+        {
+            TestUtils.AreEqual(any(int3(0, 0, 0)), false);
+            TestUtils.AreEqual(any(int3(0, 0, 1)), true);
+            TestUtils.AreEqual(any(int3(0, -1, 0)), true);
+            TestUtils.AreEqual(any(int3(0, int.MinValue, int.MaxValue)), true);
+
+            TestUtils.AreEqual(any(int3(5, 0, 0)), true);
+            TestUtils.AreEqual(any(int3(11, 0, -11)), true);
+            TestUtils.AreEqual(any(int3(-100, -32, 0)), true);
+            TestUtils.AreEqual(any(int3(-121, 100, 322)), true);
+        }
+
+        [TestCompiler]
+        public static void any_int4()
+        {
+            TestUtils.AreEqual(any(int4(0, 0, 0, 0)), false);
+            TestUtils.AreEqual(any(int4(0, 0, 0, 1)), true);
+            TestUtils.AreEqual(any(int4(0, 0, -1, 0)), true);
+            TestUtils.AreEqual(any(int4(0, 0, int.MinValue, int.MaxValue)), true);
+
+            TestUtils.AreEqual(any(int4(0, 5, 0, 0)), true);
+            TestUtils.AreEqual(any(int4(0, 11, 0, -11)), true);
+            TestUtils.AreEqual(any(int4(0, 12, 55, 0)), true);
+            TestUtils.AreEqual(any(int4(0, 100, 102, 10123)), true);
+
+            TestUtils.AreEqual(any(int4(-323, 0, 0, 0)), true);
+            TestUtils.AreEqual(any(int4(-564, 0, 0, 55)), true);
+            TestUtils.AreEqual(any(int4(23, 0, 12, 0)), true);
+            TestUtils.AreEqual(any(int4(100, 0, 55, 22)), true);
+
+            TestUtils.AreEqual(any(int4(22, -99, 0, 0)), true);
+            TestUtils.AreEqual(any(int4(33, -88, 0, 100)), true);
+            TestUtils.AreEqual(any(int4(44, -77, 0x10000, 0)), true);
+            TestUtils.AreEqual(any(int4(55, -66, 0x20000, 0x30000)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_uint2()
+        {
+            TestUtils.AreEqual(any(uint2(0u, 0u)), false);
+            TestUtils.AreEqual(any(uint2(0u, 0xFFFFFFFFu)), true);
+            TestUtils.AreEqual(any(uint2(100u, 0u)), true);
+            TestUtils.AreEqual(any(uint2(200u, 1000u)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_uint3()
+        {
+            TestUtils.AreEqual(any(uint3(0u, 0u, 0u)), false);
+            TestUtils.AreEqual(any(uint3(0u, 0u, 1u)), true);
+            TestUtils.AreEqual(any(uint3(0u, 0xFFFFFFFFu, 0u)), true);
+            TestUtils.AreEqual(any(uint3(0u, uint.MinValue, uint.MaxValue)), true);
+
+            TestUtils.AreEqual(any(uint3(5u, 0u, 0u)), true);
+            TestUtils.AreEqual(any(uint3(11u, 0u, 100u)), true);
+            TestUtils.AreEqual(any(uint3(100u, 32u, 0u)), true);
+            TestUtils.AreEqual(any(uint3(121u, 100u, 322u)), true);
+        }
+
+        [TestCompiler]
+        public static void any_uint4()
+        {
+            TestUtils.AreEqual(any(uint4(0u, 0u, 0u, 0u)), false);
+            TestUtils.AreEqual(any(uint4(0u, 0u, 0u, 1u)), true);
+            TestUtils.AreEqual(any(uint4(0u, 0u, 0xFFFFFFFFu, 0u)), true);
+            TestUtils.AreEqual(any(uint4(0u, 0u, uint.MinValue, uint.MaxValue)), true);
+
+            TestUtils.AreEqual(any(uint4(0u, 5u, 0u, 0u)), true);
+            TestUtils.AreEqual(any(uint4(0u, 11u, 0u, 22u)), true);
+            TestUtils.AreEqual(any(uint4(0u, 12u, 55u, 0u)), true);
+            TestUtils.AreEqual(any(uint4(0u, 100u, 102u, 10123u)), true);
+
+            TestUtils.AreEqual(any(uint4(323u, 0u, 0u, 0u)), true);
+            TestUtils.AreEqual(any(uint4(564u, 0u, 0u, 55u)), true);
+            TestUtils.AreEqual(any(uint4(23u, 0u, 12u, 0u)), true);
+            TestUtils.AreEqual(any(uint4(100u, 0u, 55u, 22u)), true);
+
+            TestUtils.AreEqual(any(uint4(22u, 99u, 0u, 0u)), true);
+            TestUtils.AreEqual(any(uint4(33u, 88u, 0u, 100u)), true);
+            TestUtils.AreEqual(any(uint4(44u, 77u, 0x10000, 0u)), true);
+            TestUtils.AreEqual(any(uint4(55u, 66u, 0x20000u, 0x30000u)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_float2()
+        {
+            //TestUtils.AreEqual(any(float2(0, float.NaN)), true);    // TODO: doesn't work with burst
+
+            TestUtils.AreEqual(any(float2(0, -0)), false);
+            //TestUtils.AreEqual(any(float2(0, float.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(float2(-2.0f, 0)), true);
+            TestUtils.AreEqual(any(float2(float.PositiveInfinity, float.NegativeInfinity)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_float3()
+        {
+            //TestUtils.AreEqual(any(float3(0.0f, float.NaN, 0.0f)), true);    // TODO: doesn't work with burst
+
+            TestUtils.AreEqual(any(float3(0.0f, 0.0f, 0.0f)), false);
+            //TestUtils.AreEqual(any(float3(0.0f, 0.0f, float.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(float3(0.0f, -1.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float3(0.0f, float.NegativeInfinity, float.PositiveInfinity)), true);
+
+            TestUtils.AreEqual(any(float3(float.PositiveInfinity, 0.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float3(float.MaxValue, -0.0f, 1e38f)), true);
+            TestUtils.AreEqual(any(float3(-1.2e28f, 3.2f, 0.0f)), true);
+            TestUtils.AreEqual(any(float3(121.2f, 100.0f, -32.2f)), true);
+        }
+
+        [TestCompiler]
+        public static void any_float4()
+        {
+            TestUtils.AreEqual(any(float4(0.0f, 0.0f, 0.0f, 0.0f)), false);
+            //TestUtils.AreEqual(any(float4(0.0f, 0.0f, 0.0f, float.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(float4(0.0f, 0.0f, 1.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float4(0.0f, 0.0f, float.NegativeInfinity, float.PositiveInfinity)), true);
+
+            TestUtils.AreEqual(any(float4(0.0f, float.PositiveInfinity, 0.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float4(0.0f, 11.2f, 0.0f, float.MinValue)), true);
+            TestUtils.AreEqual(any(float4(0.0f, -12.2f, float.MaxValue, 0u)), true);
+            TestUtils.AreEqual(any(float4(0.0f, -1.2e28f, -32.2f, 22.0f)), true);
+
+            TestUtils.AreEqual(any(float4(323.2f, 0.0f, 0.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float4(-564.6f, 0.0f, 0.0f, 1113f)), true);
+            TestUtils.AreEqual(any(float4(-23.0f, 0.0f, 0.2f, 0.0f)), true);
+            TestUtils.AreEqual(any(float4(102.0f, 0.0f, 5.5f, -22.0f)), true);
+
+            //TestUtils.AreEqual(any(float4(float.NaN, -99.0f, 0.0f, 0.0f)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(float4(33.0f, 88.0f, 0.0f, 100.0f)), true);
+            TestUtils.AreEqual(any(float4(44.0f, 77.0f, -2000.0f, 0.0f)), true);
+            TestUtils.AreEqual(any(float4(55.0f, 66.0f, 5000.0f, 10000.2f)), true);
+        }
+
+        [TestCompiler]
+        public static void any_double2()
+        {
+            //TestUtils.AreEqual(any(double2(0, double.NaN)), true);    // TODO: doesn't work with burst.
+
+            TestUtils.AreEqual(any(double2(0, -0)), false);
+            //TestUtils.AreEqual(any(double2(0, double.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(double2(-2.0, 0)), true);
+            TestUtils.AreEqual(any(double2(double.PositiveInfinity, double.NegativeInfinity)), true);
+        }
+
+
+        [TestCompiler]
+        public static void any_double3()
+        {
+            //TestUtils.AreEqual(any(double3(0.0, double.NaN, 0.0)), true);    // TODO: doesn't work with burst
+
+            TestUtils.AreEqual(any(double3(0.0, 0.0, 0.0)), false);
+            //TestUtils.AreEqual(any(double3(0.0, 0.0, double.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(double3(0.0, -1.0, 0.0)), true);
+            TestUtils.AreEqual(any(double3(0.0, double.NegativeInfinity, double.PositiveInfinity)), true);
+
+            TestUtils.AreEqual(any(double3(double.PositiveInfinity, 0.0, 0.0)), true);
+            TestUtils.AreEqual(any(double3(double.MaxValue, -0.0, 1e108)), true);
+            TestUtils.AreEqual(any(double3(-1.2e128, 3.2, 0.0)), true);
+            TestUtils.AreEqual(any(double3(121.2, 100.0, -32.2)), true);
+        }
+
+        [TestCompiler]
+        public static void any_double4()
+        {
+            TestUtils.AreEqual(any(double4(0.0, 0.0, 0.0, 0.0)), false);
+            //TestUtils.AreEqual(any(double4(0.0, 0.0, 0.0, double.NaN)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(double4(0.0, 0.0, 1.0, 0.0)), true);
+            TestUtils.AreEqual(any(double4(0.0, 0.0, double.NegativeInfinity, double.PositiveInfinity)), true);
+
+            TestUtils.AreEqual(any(double4(0.0, double.PositiveInfinity, 0.0, 0.0)), true);
+            TestUtils.AreEqual(any(double4(0.0, 11.2, 0.0, double.MinValue)), true);
+            TestUtils.AreEqual(any(double4(0.0, -12.2, double.MaxValue, 0.0)), true);
+            TestUtils.AreEqual(any(double4(0.0, -1.2e28, -32.2, 22.0)), true);
+
+            TestUtils.AreEqual(any(double4(323.2, 0.0, 0.0, 0.0)), true);
+            TestUtils.AreEqual(any(double4(-564.6, 0.0, 0.0, 1113.0)), true);
+            TestUtils.AreEqual(any(double4(-23.0, 0.0, 0.2, 0.0)), true);
+            TestUtils.AreEqual(any(double4(102.0, 0.0, 5.5, -22.0)), true);
+
+            //TestUtils.AreEqual(any(double4(double.NaN, -99.0, 0.0, 0.0)), true);    // TODO: doesn't work with burst
+            TestUtils.AreEqual(any(double4(33.0, 88.0, 0.0, 100.0)), true);
+            TestUtils.AreEqual(any(double4(44.0, 77.0, -2000.0, 0.0)), true);
+            TestUtils.AreEqual(any(double4(55.0, 66.0, 5000.0, 10000.2)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_bool2()
+        {
+            TestUtils.AreEqual(all(bool2(false, false)), false);
+            TestUtils.AreEqual(all(bool2(false, true)), false);
+            TestUtils.AreEqual(all(bool2(true, false)), false);
+            TestUtils.AreEqual(all(bool2(true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void all_bool3()
+        {
+            TestUtils.AreEqual(all(bool3(false, false, false)), false);
+            TestUtils.AreEqual(all(bool3(false, false, true)), false);
+            TestUtils.AreEqual(all(bool3(false, true, false)), false);
+            TestUtils.AreEqual(all(bool3(false, true, true)), false);
+
+            TestUtils.AreEqual(all(bool3(true, false, false)), false);
+            TestUtils.AreEqual(all(bool3(true, false, true)), false);
+            TestUtils.AreEqual(all(bool3(true, true, false)), false);
+            TestUtils.AreEqual(all(bool3(true, true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void all_bool4()
+        {
+            TestUtils.AreEqual(all(bool4(false, false, false, false)), false);
+            TestUtils.AreEqual(all(bool4(false, false, false, true)), false);
+            TestUtils.AreEqual(all(bool4(false, false, true, false)), false);
+            TestUtils.AreEqual(all(bool4(false, false, true, true)), false);
+
+            TestUtils.AreEqual(all(bool4(false, true, false, false)), false);
+            TestUtils.AreEqual(all(bool4(false, true, false, true)), false);
+            TestUtils.AreEqual(all(bool4(false, true, true, false)), false);
+            TestUtils.AreEqual(all(bool4(false, true, true, true)), false);
+
+            TestUtils.AreEqual(all(bool4(true, false, false, false)), false);
+            TestUtils.AreEqual(all(bool4(true, false, false, true)), false);
+            TestUtils.AreEqual(all(bool4(true, false, true, false)), false);
+            TestUtils.AreEqual(all(bool4(true, false, true, true)), false);
+
+            TestUtils.AreEqual(all(bool4(true, true, false, false)), false);
+            TestUtils.AreEqual(all(bool4(true, true, false, true)), false);
+            TestUtils.AreEqual(all(bool4(true, true, true, false)), false);
+            TestUtils.AreEqual(all(bool4(true, true, true, true)), true);
+        }
+
+        [TestCompiler]
+        public static void all_int2()
+        {
+            TestUtils.AreEqual(all(int2(0, 0)), false);
+            TestUtils.AreEqual(all(int2(0, -1)), false);
+            TestUtils.AreEqual(all(int2(1, 0)), false);
+            TestUtils.AreEqual(all(int2(2, int.MinValue)), true);
+        }
+
+        [TestCompiler]
+        public static void all_int3()
+        {
+            TestUtils.AreEqual(all(int3(0, 0, 0)), false);
+            TestUtils.AreEqual(all(int3(0, 0, 1)), false);
+            TestUtils.AreEqual(all(int3(0, -1, 0)), false);
+            TestUtils.AreEqual(all(int3(0, int.MinValue, int.MaxValue)), false);
+
+            TestUtils.AreEqual(all(int3(5, 0, 0)), false);
+            TestUtils.AreEqual(all(int3(11, 0, -11)), false);
+            TestUtils.AreEqual(all(int3(-100, -32, 0)), false);
+            TestUtils.AreEqual(all(int3(-121, 100, 322)), true);
+        }
+
+        [TestCompiler]
+        public static void all_int4()
+        {
+            TestUtils.AreEqual(all(int4(0, 0, 0, 0)), false);
+            TestUtils.AreEqual(all(int4(0, 0, 0, 1)), false);
+            TestUtils.AreEqual(all(int4(0, 0, -1, 0)), false);
+            TestUtils.AreEqual(all(int4(0, 0, int.MinValue, int.MaxValue)), false);
+
+            TestUtils.AreEqual(all(int4(0, 5, 0, 0)), false);
+            TestUtils.AreEqual(all(int4(0, 11, 0, -11)), false);
+            TestUtils.AreEqual(all(int4(0, 12, 55, 0)), false);
+            TestUtils.AreEqual(all(int4(0, 100, 102, 10123)), false);
+
+            TestUtils.AreEqual(all(int4(-323, 0, 0, 0)), false);
+            TestUtils.AreEqual(all(int4(-564, 0, 0, 55)), false);
+            TestUtils.AreEqual(all(int4(23, 0, 12, 0)), false);
+            TestUtils.AreEqual(all(int4(100, 0, 55, 22)), false);
+
+            TestUtils.AreEqual(all(int4(22, -99, 0, 0)), false);
+            TestUtils.AreEqual(all(int4(33, -88, 0, 100)), false);
+            TestUtils.AreEqual(all(int4(44, -77, 0x10000, 0)), false);
+            TestUtils.AreEqual(all(int4(55, -66, 0x20000, 0x30000)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_uint2()
+        {
+            TestUtils.AreEqual(all(uint2(0u, 0u)), false);
+            TestUtils.AreEqual(all(uint2(0u, 0xFFFFFFFFu)), false);
+            TestUtils.AreEqual(all(uint2(100u, 0u)), false);
+            TestUtils.AreEqual(all(uint2(200u, 1000u)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_uint3()
+        {
+            TestUtils.AreEqual(all(uint3(0u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint3(0u, 0u, 1u)), false);
+            TestUtils.AreEqual(all(uint3(0u, 0xFFFFFFFFu, 0u)), false);
+            TestUtils.AreEqual(all(uint3(0u, uint.MinValue, uint.MaxValue)), false);
+
+            TestUtils.AreEqual(all(uint3(5u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint3(11u, 0u, 100u)), false);
+            TestUtils.AreEqual(all(uint3(100u, 32u, 0u)), false);
+            TestUtils.AreEqual(all(uint3(121u, 100u, 322u)), true);
+        }
+
+        [TestCompiler]
+        public static void all_uint4()
+        {
+            TestUtils.AreEqual(all(uint4(0u, 0u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 0u, 0u, 1u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 0u, 0xFFFFFFFFu, 0u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 0u, uint.MinValue, uint.MaxValue)), false);
+
+            TestUtils.AreEqual(all(uint4(0u, 5u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 11u, 0u, 22u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 12u, 55u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(0u, 100u, 102u, 10123u)), false);
+
+            TestUtils.AreEqual(all(uint4(323u, 0u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(564u, 0u, 0u, 55u)), false);
+            TestUtils.AreEqual(all(uint4(23u, 0u, 12u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(100u, 0u, 55u, 22u)), false);
+
+            TestUtils.AreEqual(all(uint4(22u, 99u, 0u, 0u)), false);
+            TestUtils.AreEqual(all(uint4(33u, 88u, 0u, 100u)), false);
+            TestUtils.AreEqual(all(uint4(44u, 77u, 0x10000, 0u)), false);
+            TestUtils.AreEqual(all(uint4(55u, 66u, 0x20000u, 0x30000u)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_float2()
+        {
+            TestUtils.AreEqual(all(float2(float.NaN, float.NaN)), true);
+
+            TestUtils.AreEqual(all(float2(0, -0)), false);
+            TestUtils.AreEqual(all(float2(0, float.NaN)), false);
+            TestUtils.AreEqual(all(float2(-2.0f, 0)), false);
+            TestUtils.AreEqual(all(float2(float.PositiveInfinity, float.NegativeInfinity)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_float3()
+        {
+            TestUtils.AreEqual(all(float3(float.NaN, float.NaN, float.NaN)), true);
+
+            TestUtils.AreEqual(all(float3(0.0f, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float3(0.0f, 0.0f, float.NaN)), false);
+            TestUtils.AreEqual(all(float3(0.0f, -1.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float3(0.0f, float.NegativeInfinity, float.PositiveInfinity)), false);
+
+            TestUtils.AreEqual(all(float3(float.PositiveInfinity, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float3(float.MaxValue, -0.0f, 1e38f)), false);
+            TestUtils.AreEqual(all(float3(-1.2e28f, 3.2f, 0.0f)), false);
+            TestUtils.AreEqual(all(float3(121.2f, 100.0f, -32.2f)), true);
+        }
+
+        [TestCompiler]
+        public static void all_float4()
+        {
+            TestUtils.AreEqual(all(float4(float.NaN, float.NaN, float.NaN, float.NaN)), true);
+
+            TestUtils.AreEqual(all(float4(0.0f, 0.0f, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(0.0f, 0.0f, 0.0f, float.NaN)), false);
+            TestUtils.AreEqual(all(float4(0.0f, 0.0f, 1.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(0.0f, 0.0f, float.NegativeInfinity, float.PositiveInfinity)), false);
+
+            TestUtils.AreEqual(all(float4(0.0f, float.PositiveInfinity, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(0.0f, 11.2f, 0.0f, float.MinValue)), false);
+            TestUtils.AreEqual(all(float4(0.0f, -12.2f, float.MaxValue, 0u)), false);
+            TestUtils.AreEqual(all(float4(0.0f, -1.2e28f, -32.2f, 22.0f)), false);
+
+            TestUtils.AreEqual(all(float4(323.2f, 0.0f, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(-564.6f, 0.0f, 0.0f, 1113f)), false);
+            TestUtils.AreEqual(all(float4(-23.0f, 0.0f, 0.2f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(102.0f, 0.0f, 5.5f, -22.0f)), false);
+
+            TestUtils.AreEqual(all(float4(float.NaN, -99.0f, 0.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(33.0f, 88.0f, 0.0f, 100.0f)), false);
+            TestUtils.AreEqual(all(float4(44.0f, 77.0f, -2000.0f, 0.0f)), false);
+            TestUtils.AreEqual(all(float4(55.0f, 66.0f, 5000.0f, 10000.2f)), true);
+        }
+
+        [TestCompiler]
+        public static void all_double2()
+        {
+            TestUtils.AreEqual(all(double2(double.NaN, double.NaN)), true);
+
+            TestUtils.AreEqual(all(double2(0, -0)), false);
+            TestUtils.AreEqual(all(double2(0, double.NaN)), false);
+            TestUtils.AreEqual(all(double2(-2.0, 0)), false);
+            TestUtils.AreEqual(all(double2(double.PositiveInfinity, double.NegativeInfinity)), true);
+        }
+
+
+        [TestCompiler]
+        public static void all_double3()
+        {
+            TestUtils.AreEqual(all(double3(double.NaN, double.NaN, double.NaN)), true);
+
+            TestUtils.AreEqual(all(double3(0.0, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double3(0.0, 0.0, double.NaN)), false);
+            TestUtils.AreEqual(all(double3(0.0, -1.0, 0.0)), false);
+            TestUtils.AreEqual(all(double3(0.0, double.NegativeInfinity, double.PositiveInfinity)), false);
+
+            TestUtils.AreEqual(all(double3(double.PositiveInfinity, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double3(double.MaxValue, -0.0, 1e108)), false);
+            TestUtils.AreEqual(all(double3(-1.2e128, 3.2, 0.0)), false);
+            TestUtils.AreEqual(all(double3(121.2, 100.0, -32.2)), true);
+        }
+
+        [TestCompiler]
+        public static void all_double4()
+        {
+            TestUtils.AreEqual(all(double4(double.NaN, double.NaN, double.NaN, double.NaN)), true);
+
+            TestUtils.AreEqual(all(double4(0.0, 0.0, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(0.0, 0.0, 0.0, double.NaN)), false);
+            TestUtils.AreEqual(all(double4(0.0, 0.0, 1.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(0.0, 0.0, double.NegativeInfinity, double.PositiveInfinity)), false);
+
+            TestUtils.AreEqual(all(double4(0.0, double.PositiveInfinity, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(0.0, 11.2, 0.0, double.MinValue)), false);
+            TestUtils.AreEqual(all(double4(0.0, -12.2, double.MaxValue, 0.0)), false);
+            TestUtils.AreEqual(all(double4(0.0, -1.2e28, -32.2, 22.0)), false);
+
+            TestUtils.AreEqual(all(double4(323.2, 0.0, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(-564.6, 0.0, 0.0, 1113.0)), false);
+            TestUtils.AreEqual(all(double4(-23.0, 0.0, 0.2, 0.0)), false);
+            TestUtils.AreEqual(all(double4(102.0, 0.0, 5.5, -22.0)), false);
+
+            TestUtils.AreEqual(all(double4(double.NaN, -99.0, 0.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(33.0, 88.0, 0.0, 100.0)), false);
+            TestUtils.AreEqual(all(double4(44.0, 77.0, -2000.0, 0.0)), false);
+            TestUtils.AreEqual(all(double4(55.0, 66.0, 5000.0, 10000.2)), true);
+        }
+
+
+        [TestCompiler]
+        public static void length_float2()
+        {
+            TestUtils.AreEqual(length(float2(0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(length(float2(1.2f, -2.6f)), 2.86356421265527063f, 8, false);
+            TestUtils.AreEqual(length(float2(1.2f, float.NaN)), float.NaN, 0, false);
+            TestUtils.AreEqual(length(float2(1.2f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(float2(1.2f, float.NegativeInfinity)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(float2(-1.2e18f, 2.6e18f)), 2.863564e18f, 8, false);
+            TestUtils.AreEqual(length(float2(-1.2e19f, -2.6e19f)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void length_float3()
+        {
+            TestUtils.AreEqual(length(float3(0.0f, 0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(length(float3(1.2f, -2.6f, 2.2f)), 3.611094f, 8, false);
+            TestUtils.AreEqual(length(float3(1.2f, float.NaN, 2.2f)), float.NaN, 0, false);
+            TestUtils.AreEqual(length(float3(1.2f, float.PositiveInfinity, 2.2f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(float3(1.2f, float.NegativeInfinity, 2.2f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(float3(-1.2e18f, 2.6e18f, 2.2e18f)), 3.611094e18f, 8, false);
+            TestUtils.AreEqual(length(float3(-1.2e19f, -2.6e19f, 2.2e19f)), float.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void length_float4()
+        {
+            TestUtils.AreEqual(length(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(length(float4(1.2f, -2.6f, 2.2f, -4.2f)), 5.538953f, 8, false);
+            TestUtils.AreEqual(length(float4(1.2f, float.NaN, 2.2f, -4.2f)), float.NaN, 0, false);
+            TestUtils.AreEqual(length(float4(1.2f, float.PositiveInfinity, 2.2f, -4.2f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(float4(1.2f, float.NegativeInfinity, 2.2f, -4.2f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(float4(-1.2e18f, 2.6e18f, 2.2e18f, -4.2e18f)), 5.538953e18f, 8, false);
+            TestUtils.AreEqual(length(float4(-1.2e19f, -2.6e19f, 2.2e19f, -4.2e19f)), float.PositiveInfinity, 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void length_double2()
+        {
+            TestUtils.AreEqual(length(double2(0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(length(double2(1.2, -2.6)), 2.86356421265527063, 8, false);
+            TestUtils.AreEqual(length(double2(1.2, double.NaN)), double.NaN, 0, false);
+            TestUtils.AreEqual(length(double2(1.2, double.PositiveInfinity)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(double2(1.2, double.NegativeInfinity)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(double2(-1.2e153, 2.6e153)), 2.86356421265527063e153, 8, false);
+        }
+
+        [TestCompiler]
+        public static void length_double3()
+        {
+            TestUtils.AreEqual(length(double3(0.0, 0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(length(double3(1.2, -2.6, 2.2)), 3.6110940170535577, 8, false);
+            TestUtils.AreEqual(length(double3(1.2, double.NaN, 2.2)), double.NaN, 0, false);
+            TestUtils.AreEqual(length(double3(1.2, double.PositiveInfinity, 2.2)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(double3(1.2, double.NegativeInfinity, 2.2)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(double3(-1.2e153, 2.6e153, 2.2e153)), 3.6110940170535577e153, 8, false);
+        }
+
+        [TestCompiler]
+        public static void length_double4()
+        {
+            TestUtils.AreEqual(length(double4(0.0, 0.0, 0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(length(double4(1.2, -2.6, 2.2, -4.2)), 5.5389529696504916, 8, false);
+            TestUtils.AreEqual(length(double4(1.2, double.NaN, 2.2, -4.2)), double.NaN, 0, false);
+            TestUtils.AreEqual(length(double4(1.2, double.PositiveInfinity, 2.2, -4.2)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(length(double4(1.2, double.NegativeInfinity, 2.2, -4.2)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(length(double4(-1.2e153, 2.6e153, 2.2e153, -4.2e153)), 5.5389529696504916e153, 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void lengthsq_float2()
+        {
+            TestUtils.AreEqual(lengthsq(float2(0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(lengthsq(float2(1.2f, -2.6f)), 8.2f, 8, false);
+            TestUtils.AreEqual(lengthsq(float2(1.2f, float.NaN)), float.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(float2(1.2f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(float2(1.2f, float.NegativeInfinity)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(float2(-1.2e18f, 2.6e18f)), 8.2e36f, 8, false);
+        }
+
+        [TestCompiler]
+        public static void lengthsq_float3()
+        {
+            TestUtils.AreEqual(lengthsq(float3(0.0f, 0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(lengthsq(float3(1.2f, -2.6f, 2.2f)), 13.04f, 8, false);
+            TestUtils.AreEqual(lengthsq(float3(1.2f, float.NaN, 2.2f)), float.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(float3(1.2f, float.PositiveInfinity, 2.2f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(float3(1.2f, float.NegativeInfinity, 2.2f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(float3(-1.2e18f, 2.6e18f, 2.2e18f)), 1.304e37f, 8, false);
+            TestUtils.AreEqual(lengthsq(float3(-1.2e19f, -2.6e19f, 2.2e19f)), float.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void lengthsq_float4()
+        {
+            TestUtils.AreEqual(lengthsq(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0.0f, 0, false);
+            TestUtils.AreEqual(lengthsq(float4(1.2f, -2.6f, 2.2f, -4.2f)), 30.68f, 8, false);
+            TestUtils.AreEqual(lengthsq(float4(1.2f, float.NaN, 2.2f, -4.2f)), float.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(float4(1.2f, float.PositiveInfinity, 2.2f, -4.2f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(float4(1.2f, float.NegativeInfinity, 2.2f, -4.2f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(float4(-1.2e18f, 2.6e18f, 2.2e18f, -4.2e18f)), 3.068e37f, 8, false);
+            TestUtils.AreEqual(lengthsq(float4(-1.2e19f, -2.6e19f, 2.2e19f, -4.2e19f)), float.PositiveInfinity, 8, false);
+        }
+
+
+        [TestCompiler]
+        public static void lengthsq_double2()
+        {
+            TestUtils.AreEqual(lengthsq(double2(0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(lengthsq(double2(1.2, -2.6)), 8.2, 8, false);
+            TestUtils.AreEqual(lengthsq(double2(1.2, double.NaN)), double.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(double2(1.2, double.PositiveInfinity)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(double2(1.2, double.NegativeInfinity)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(double2(-1.2e153, 2.6e153)), 8.2e306, 8, false);
+            TestUtils.AreEqual(lengthsq(double2(-1.2e154, -2.6e154)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void lengthsq_double3()
+        {
+            TestUtils.AreEqual(lengthsq(double3(0.0, 0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(lengthsq(double3(1.2, -2.6, 2.2)), 13.04, 8, false);
+            TestUtils.AreEqual(lengthsq(double3(1.2, double.NaN, 2.2)), double.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(double3(1.2, double.PositiveInfinity, 2.2)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(double3(1.2, double.NegativeInfinity, 2.2)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(double3(-1.2e153, 2.6e153, 2.2e153)), 1.304e307, 8, false);
+            TestUtils.AreEqual(lengthsq(double3(-1.2e154, -2.6e154, 2.2e154)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void lengthsq_double4()
+        {
+            TestUtils.AreEqual(lengthsq(double4(0.0, 0.0, 0.0, 0.0)), 0.0, 0, false);
+            TestUtils.AreEqual(lengthsq(double4(1.2, -2.6, 2.2, -4.2)), 30.68, 8, false);
+            TestUtils.AreEqual(lengthsq(double4(1.2, double.NaN, 2.2, -4.2)), double.NaN, 0, false);
+            TestUtils.AreEqual(lengthsq(double4(1.2, double.PositiveInfinity, 2.2, -4.2)), double.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(lengthsq(double4(1.2, double.NegativeInfinity, 2.2, -4.2)), double.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(lengthsq(double4(-1.2e153, 2.6e153, 2.2e153, -4.2e153)), 3.068e307, 8, false);
+            TestUtils.AreEqual(lengthsq(double4(-1.2e154, -2.6e154, 2.2e154, -4.2e154)), double.PositiveInfinity, 0, false);
+        }
+
+
+
+
+        [TestCompiler]
+        public static void distance_float2()
+        {
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0.0f, 0, false);
+
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(-5.3f, 4.3f)), 9.404786f, 8, false);
+            TestUtils.AreEqual(distance(float2(1.3e18f, -2.4e18f), float2(-5.3e18f, 4.3e18f)), 9.404786e18f, 8, false);
+            TestUtils.AreEqual(distance(float2(1.3e19f, -2.4e19f), float2(-5.3e19f, 4.3e19f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(float.NaN, 4.3f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), float.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distance_float3()
+        {
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0.0f, 0, false);
+
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(-5.3f, 4.3f)), 9.404786f, 8, false);
+            TestUtils.AreEqual(distance(float2(1.3e18f, -2.4e18f), float2(-5.3e18f, 4.3e18f)), 9.404786e18f, 8, false);
+            TestUtils.AreEqual(distance(float2(1.3e19f, -2.4e19f), float2(-5.3e19f, 4.3e19f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(float.NaN, 4.3f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distance(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), float.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distance_float4()
+        {
+            TestUtils.AreEqual(distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(-5.3f, 4.3f, 4.7f, 0.3f)), 9.863569f, 8, false);
+            TestUtils.AreEqual(distance(float4(1.3e18f, -2.4e18f, 5.7e18f, 3.1e18f), float4(-5.3e18f, 4.3e18f, 4.7e18f, 3e17f)), 9.863569e18f, 8, false);
+            TestUtils.AreEqual(distance(float4(1.3e19f, -2.4e19f, 5.7e19f, 3.1e19f), float4(-5.3e19f, 4.3e19f, 4.7e19f, 3e18f)), float.PositiveInfinity, 0, false);
+
+            TestUtils.AreEqual(distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(float.NaN, 4.3f, 4.7f, 0.3f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(-5.3f, float.PositiveInfinity, 4.7f, 0.3f)), float.PositiveInfinity, 0, false);
+            TestUtils.AreEqual(distance(float4(1.3f, float.NegativeInfinity, 5.7f, 3.1f), double4(-5.3f, 4.3f, 4.7f, 0.3f)), float.PositiveInfinity, 0, false);
+        }
+
+
+        [TestCompiler]
+        public static void distance_double2()
+        {
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(-5.3, 4.3)), 9.4047860156411852, 8, false);
+            TestUtils.AreEqual(distance(double2(1.3e153, -2.4e153), double2(-5.3e153, 4.3e153)), 9.4047860156411852e153, 8, false);
+            TestUtils.AreEqual(distance(double2(1.3e154, -2.4e154), double2(-5.3e154, 4.3e154)), double.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(double.NaN, 4.3)), double.NaN, 0, false);
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), double.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distance_double3()
+        {
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(-5.3, 4.3)), 9.4047860156411852, 8, false);
+            TestUtils.AreEqual(distance(double2(1.3e153, -2.4e153), double2(-5.3e153, 4.3e153)), 9.4047860156411852e153, 8, false);
+            TestUtils.AreEqual(distance(double2(1.3e154, -2.4e154), double2(-5.3e154, 4.3e154)), double.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(double.NaN, 4.3)), double.NaN, 0, false);
+            TestUtils.AreEqual(distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), double.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distance_double4()
+        {
+            TestUtils.AreEqual(distance(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distance(double4(1.3, -2.4, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 9.8635693336641579, 8, false);
+            TestUtils.AreEqual(distance(double4(1.3e153, -2.4e153, 5.7e153, 3.1e153), double4(-5.3e153, 4.3e153, 4.7e153, 3e152)), 9.8635693336641579e153, 8, false);
+
+            TestUtils.AreEqual(distance(double4(1.3, -2.4, 5.7, 3.1), double4(double.NaN, 4.3, 4.7, 0.3)), double.NaN, 0, false);
+            TestUtils.AreEqual(distance(double4(1.3, -2.4, 5.7, 3.1), double4(-5.3, double.PositiveInfinity, 4.7, 0.3)), double.PositiveInfinity, 0, false);
+        }
+
+
+        [TestCompiler]
+        public static void distancesq_float2()
+        {
+            TestUtils.AreEqual(distancesq(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0.0f, 0, false);
+
+            TestUtils.AreEqual(distancesq(float2(1.3f, -2.4f), float2(-5.3f, 4.3f)), 88.45f, 8, false);
+            TestUtils.AreEqual(distancesq(float2(1.3e18f, -2.4e18f), float2(-5.3e18f, 4.3e18f)), 8.845e37f, 8, false);
+            
+            TestUtils.AreEqual(distancesq(float2(1.3f, -2.4f), float2(float.NaN, 4.3f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), float.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distancesq_float3()
+        {
+            TestUtils.AreEqual(distancesq(float3(1.3f, -2.4f, 5.7f), float3(1.3f, -2.4f, 5.7f)), 0.0f, 0, false);
+
+            TestUtils.AreEqual(distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, 4.3f, 4.7f)), 89.45f, 8, false);
+            TestUtils.AreEqual(distancesq(float3(1.3e18f, -2.4e18f, 5.7e18f), float3(-5.3e18f, 4.3e18f, 4.7e18f)), 8.945e37f, 8, false);
+            TestUtils.AreEqual(distancesq(float3(1.3e19f, -2.4e19f, 5.7e19f), float3(-5.3e19f, 4.3e19f, 4.7e19f)), float.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distancesq(float3(1.3f, -2.4f, 5.7f), float3(float.NaN, 4.3f, 4.7f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, float.PositiveInfinity, 4.7f)), float.PositiveInfinity, 0, false);
+        }
+
+        [TestCompiler]
+        public static void distancesq_float4()
+        {
+            TestUtils.AreEqual(distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0.0f, 0, false);
+
+            TestUtils.AreEqual(distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(-5.3f, 4.3f, 4.7f, 0.3f)), 97.29f, 8, false);
+            TestUtils.AreEqual(distancesq(float4(1.3e18f, -2.4e18f, 5.7e18f, 3.1e18f), float4(-5.3e18f, 4.3e18f, 4.7e18f, 3e17f)), 9.729e37f, 8, false);
+
+            TestUtils.AreEqual(distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(float.NaN, 4.3f, 4.7f, 0.3f)), float.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(-5.3f, float.PositiveInfinity, 4.7f, 0.3f)), float.PositiveInfinity, 0, false);
+        }
+
+
+        [TestCompiler]
+        public static void distancesq_double2()
+        {
+            TestUtils.AreEqual(distancesq(double2(1.3, -2.4), double2(1.3, -2.4)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distancesq(double2(1.3, -2.4), double2(-5.3, 4.3)), 88.45, 8, false);
+            TestUtils.AreEqual(distancesq(double2(1.3e153, -2.4e153), double2(-5.3e153, 4.3e153)), 8.845e307, 8, false);
+            TestUtils.AreEqual(distancesq(double2(1.3e154, -2.4e154), double2(-5.3e154, 4.3e154)), double.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distancesq(double2(1.3, -2.4), double2(double.NaN, 4.3)), double.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), double.PositiveInfinity, 8, false);
+            TestUtils.AreEqual(distancesq(double2(1.3, double.NegativeInfinity), double2(-5.3, 4.3)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void distancesq_double3()
+        {
+            TestUtils.AreEqual(distancesq(double3(1.3, -2.4, 5.7), double3(1.3, -2.4, 5.7)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distancesq(double3(1.3, -2.4, 5.7), double3(-5.3, 4.3, 4.7)), 89.45, 8, false);
+            TestUtils.AreEqual(distancesq(double3(1.3e153, -2.4e153, 5.7e153), double3(-5.3e153, 4.3e153, 4.7e153)), 8.945e307, 8, false);
+            TestUtils.AreEqual(distancesq(double3(1.3e154, -2.4e154, 5.7e154), double3(-5.3e154, 4.3e154, 4.7e154)), double.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distancesq(double3(1.3, -2.4, 5.7), double3(double.NaN, 4.3, 4.7)), double.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(double3(1.3, -2.4, 5.7), double3(-5.3, double.PositiveInfinity, 4.7)), double.PositiveInfinity, 8, false);
+            TestUtils.AreEqual(distancesq(double3(1.3, double.NegativeInfinity, 5.7), double3(-5.3, 4.3, 4.7)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        public static void distancesq_double4()
+        {
+            TestUtils.AreEqual(distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0.0, 0, false);
+
+            TestUtils.AreEqual(distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 97.29, 8, false);
+            TestUtils.AreEqual(distancesq(double4(1.3e153, -2.4e153, 5.7e153, 3.1e153), double4(-5.3e153, 4.3e153, 4.7e153, 3e152)), 9.729e307, 8, false);
+            TestUtils.AreEqual(distancesq(double4(1.3e154, -2.4e154, 5.7e154, 3.1e153), double4(-5.3e154, 4.3e154, 4.7e154, 3e153)), double.PositiveInfinity, 8, false);
+
+            TestUtils.AreEqual(distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(double.NaN, 4.3, 4.7, 0.3)), double.NaN, 0, false);
+            TestUtils.AreEqual(distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(-5.3, double.PositiveInfinity, 4.7, 0.3)), double.PositiveInfinity, 8, false);
+            TestUtils.AreEqual(distancesq(double4(1.3, double.NegativeInfinity, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), double.PositiveInfinity, 8, false);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_float_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(-0.0f), float.NegativeInfinity);
+            TestUtils.AreEqual(rcp(float.NegativeInfinity), -0.0f);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_float2_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(float2(-0.0f, float.NegativeInfinity)), float2(float.NegativeInfinity, -0.0f));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_float3_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(float3(-0.0f, float.NegativeInfinity, -0.0f)), float3(float.NegativeInfinity, -0.0f, float.NegativeInfinity));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_float4_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(float4(-0.0f, float.NegativeInfinity, -0.0f, float.NegativeInfinity)), float4(float.NegativeInfinity, -0.0f, float.NegativeInfinity, -0.0f));
+        }
+
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_double_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(-0.0), double.NegativeInfinity);
+            TestUtils.AreEqual(rcp(double.NegativeInfinity), -0.0);
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_double2_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(double2(-0.0, double.NegativeInfinity)), double2(double.NegativeInfinity, -0.0));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_double3_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(double3(-0.0, double.NegativeInfinity, -0.0)), double3(double.NegativeInfinity, -0.0, double.NegativeInfinity));
+        }
+
+        [TestCompiler]
+        [WindowsOnly("Mono on linux ignores signed zero.")]
+        public static void rcp_double4_signed_zero()
+        {
+            TestUtils.AreEqual(rcp(double4(-0.0, double.NegativeInfinity, -0.0, double.NegativeInfinity)), double4(double.NegativeInfinity, -0.0, double.NegativeInfinity, -0.0));
+        }
+
+        [TestCompiler]
+        unsafe public static void compress_test()
+        {
+            int4 value = int4(0x12345678, 0x2468ACE0, 0x369BE147, 0x48C059D1);
+
+            int ptrOffset = 4;
+            int* dest = stackalloc int[16];
+            int* ptr = dest + ptrOffset;
+
+            for(int offset = -4; offset <= 4; offset++)
+            {
+                for (int m = 0; m < 16; m++)
+                {
+                    for (int i = 0; i < 16; i++)
+                        dest[i] = 0;
+
+                    bool4 mask = bool4((m & 1) != 0, (m & 2) != 0, (m & 4) != 0, (m & 8) != 0);
+                    compress(ptr, offset, value, mask);
+
+                    for(int i = 0; i < 16; i++)
+                    {
+                        int vectorIdx = i - (ptrOffset + offset);
+
+                        int v = 0;
+                        if (vectorIdx >= 0 && vectorIdx < 4)
+                        {
+                            for(int k = 0; k < 4; k++)
+                            {
+                                if (mask[k] && vectorIdx-- == 0)
+                                    v = value[k];
+                            }
+                        }
+                        TestUtils.AreEqual(dest[i], v);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..40ad0f276197632e86c34adcf49aac933b5363c6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4fca0e2ff0321404da5c0ab527bdc756
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..b557e40976f947c9dc7912498821b071d423b71d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs
@@ -0,0 +1,4139 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public partial class TestMath
+    {
+        [TestCompiler]
+        public static void abs_int()
+        {
+            TestUtils.AreEqual(abs(0), 0);
+            TestUtils.AreEqual(abs(-7), 7);
+            TestUtils.AreEqual(abs(11), 11);
+            TestUtils.AreEqual(abs(-2147483647), 2147483647);
+            TestUtils.AreEqual(abs(-2147483648), -2147483648);
+        }
+
+        [TestCompiler]
+        public static void abs_int2()
+        {
+            TestUtils.AreEqual(abs(int2(0, -7)), int2(0, 7));
+            TestUtils.AreEqual(abs(int2(11, -2147483647)), int2(11, 2147483647));
+            TestUtils.AreEqual(abs(int2(-2147483648, -2147483648)), int2(-2147483648, -2147483648));
+        }
+
+        [TestCompiler]
+        public static void abs_int3()
+        {
+            TestUtils.AreEqual(abs(int3(0, -7, 11)), int3(0, 7, 11));
+            TestUtils.AreEqual(abs(int3(-2147483647, -2147483648, -2147483648)), int3(2147483647, -2147483648, -2147483648));
+        }
+
+        [TestCompiler]
+        public static void abs_int4()
+        {
+            TestUtils.AreEqual(abs(int4(0, -7, 11, -2147483647)), int4(0, 7, 11, 2147483647));
+            TestUtils.AreEqual(abs(int4(-2147483648, -2147483648, -2147483648, -2147483648)), int4(-2147483648, -2147483648, -2147483648, -2147483648));
+        }
+
+        [TestCompiler]
+        public static void abs_float()
+        {
+            TestUtils.AreEqual(abs(0f), 0f);
+            TestUtils.AreEqual(abs(-1.1f), 1.1f);
+            TestUtils.AreEqual(abs(2.2f), 2.2f);
+            TestUtils.AreEqual(abs(float.NegativeInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(abs(float.PositiveInfinity), float.PositiveInfinity);
+        }
+
+        [TestCompiler]
+        public static void abs_float2()
+        {
+            TestUtils.AreEqual(abs(float2(0f, -1.1f)), float2(0f, 1.1f));
+            TestUtils.AreEqual(abs(float2(2.2f, float.NegativeInfinity)), float2(2.2f, float.PositiveInfinity));
+            TestUtils.AreEqual(abs(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void abs_float3()
+        {
+            TestUtils.AreEqual(abs(float3(0f, -1.1f, 2.2f)), float3(0f, 1.1f, 2.2f));
+            TestUtils.AreEqual(abs(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void abs_float4()
+        {
+            TestUtils.AreEqual(abs(float4(0f, -1.1f, 2.2f, float.NegativeInfinity)), float4(0f, 1.1f, 2.2f, float.PositiveInfinity));
+            TestUtils.AreEqual(abs(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void abs_double()
+        {
+            TestUtils.AreEqual(abs(0.0), 0.0);
+            TestUtils.AreEqual(abs(-1.1), 1.1);
+            TestUtils.AreEqual(abs(2.2), 2.2);
+            TestUtils.AreEqual(abs(double.NegativeInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(abs(double.PositiveInfinity), double.PositiveInfinity);
+        }
+
+        [TestCompiler]
+        public static void abs_double2()
+        {
+            TestUtils.AreEqual(abs(double2(0.0, -1.1)), double2(0.0, 1.1));
+            TestUtils.AreEqual(abs(double2(2.2, double.NegativeInfinity)), double2(2.2, double.PositiveInfinity));
+            TestUtils.AreEqual(abs(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void abs_double3()
+        {
+            TestUtils.AreEqual(abs(double3(0.0, -1.1, 2.2)), double3(0.0, 1.1, 2.2));
+            TestUtils.AreEqual(abs(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void abs_double4()
+        {
+            TestUtils.AreEqual(abs(double4(0.0, -1.1, 2.2, double.NegativeInfinity)), double4(0.0, 1.1, 2.2, double.PositiveInfinity));
+            TestUtils.AreEqual(abs(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity));
+        }
+
+        [TestCompiler]
+        public static void isfinite_float()
+        {
+            TestUtils.AreEqual(isfinite(-float.NaN), false);
+            TestUtils.AreEqual(isfinite(float.NegativeInfinity), false);
+            TestUtils.AreEqual(isfinite(float.MinValue), true);
+            TestUtils.AreEqual(isfinite(-1f), true);
+            TestUtils.AreEqual(isfinite(0f), true);
+            TestUtils.AreEqual(isfinite(1f), true);
+            TestUtils.AreEqual(isfinite(float.MaxValue), true);
+            TestUtils.AreEqual(isfinite(float.PositiveInfinity), false);
+            TestUtils.AreEqual(isfinite(float.NaN), false);
+        }
+
+        [TestCompiler]
+        public static void isfinite_float2()
+        {
+            TestUtils.AreEqual(isfinite(float2(-float.NaN, float.NegativeInfinity)), bool2(false, false));
+            TestUtils.AreEqual(isfinite(float2(float.MinValue, -1f)), bool2(true, true));
+            TestUtils.AreEqual(isfinite(float2(0f, 1f)), bool2(true, true));
+            TestUtils.AreEqual(isfinite(float2(float.MaxValue, float.PositiveInfinity)), bool2(true, false));
+            TestUtils.AreEqual(isfinite(float2(float.NaN, float.NaN)), bool2(false, false));
+        }
+
+        [TestCompiler]
+        public static void isfinite_float3()
+        {
+            TestUtils.AreEqual(isfinite(float3(-float.NaN, float.NegativeInfinity, float.MinValue)), bool3(false, false, true));
+            TestUtils.AreEqual(isfinite(float3(-1f, 0f, 1f)), bool3(true, true, true));
+            TestUtils.AreEqual(isfinite(float3(float.MaxValue, float.PositiveInfinity, float.NaN)), bool3(true, false, false));
+        }
+
+        [TestCompiler]
+        public static void isfinite_float4()
+        {
+            TestUtils.AreEqual(isfinite(float4(-float.NaN, float.NegativeInfinity, float.MinValue, -1f)), bool4(false, false, true, true));
+            TestUtils.AreEqual(isfinite(float4(0f, 1f, float.MaxValue, float.PositiveInfinity)), bool4(true, true, true, false));
+            TestUtils.AreEqual(isfinite(float4(float.NaN, float.NaN, float.NaN, float.NaN)), bool4(false, false, false, false));
+        }
+
+        [TestCompiler]
+        public static void isfinite_double()
+        {
+            TestUtils.AreEqual(isfinite(-double.NaN), false);
+            TestUtils.AreEqual(isfinite(double.NegativeInfinity), false);
+            TestUtils.AreEqual(isfinite(double.MinValue), true);
+            TestUtils.AreEqual(isfinite(-1.0), true);
+            TestUtils.AreEqual(isfinite(0.0), true);
+            TestUtils.AreEqual(isfinite(1.0), true);
+            TestUtils.AreEqual(isfinite(double.MaxValue), true);
+            TestUtils.AreEqual(isfinite(double.PositiveInfinity), false);
+            TestUtils.AreEqual(isfinite(double.NaN), false);
+        }
+
+        [TestCompiler]
+        public static void isfinite_double2()
+        {
+            TestUtils.AreEqual(isfinite(double2(-double.NaN, double.NegativeInfinity)), bool2(false, false));
+            TestUtils.AreEqual(isfinite(double2(double.MinValue, -1.0)), bool2(true, true));
+            TestUtils.AreEqual(isfinite(double2(0.0, 1.0)), bool2(true, true));
+            TestUtils.AreEqual(isfinite(double2(double.MaxValue, double.PositiveInfinity)), bool2(true, false));
+            TestUtils.AreEqual(isfinite(double2(double.NaN, double.NaN)), bool2(false, false));
+        }
+
+        [TestCompiler]
+        public static void isfinite_double3()
+        {
+            TestUtils.AreEqual(isfinite(double3(-double.NaN, double.NegativeInfinity, double.MinValue)), bool3(false, false, true));
+            TestUtils.AreEqual(isfinite(double3(-1.0, 0.0, 1.0)), bool3(true, true, true));
+            TestUtils.AreEqual(isfinite(double3(double.MaxValue, double.PositiveInfinity, double.NaN)), bool3(true, false, false));
+        }
+
+        [TestCompiler]
+        public static void isfinite_double4()
+        {
+            TestUtils.AreEqual(isfinite(double4(-double.NaN, double.NegativeInfinity, double.MinValue, -1.0)), bool4(false, false, true, true));
+            TestUtils.AreEqual(isfinite(double4(0.0, 1.0, double.MaxValue, double.PositiveInfinity)), bool4(true, true, true, false));
+            TestUtils.AreEqual(isfinite(double4(double.NaN, double.NaN, double.NaN, double.NaN)), bool4(false, false, false, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_float()
+        {
+            TestUtils.AreEqual(isinf(-float.NaN), false);
+            TestUtils.AreEqual(isinf(float.NegativeInfinity), true);
+            TestUtils.AreEqual(isinf(float.MinValue), false);
+            TestUtils.AreEqual(isinf(-1f), false);
+            TestUtils.AreEqual(isinf(0f), false);
+            TestUtils.AreEqual(isinf(1f), false);
+            TestUtils.AreEqual(isinf(float.MaxValue), false);
+            TestUtils.AreEqual(isinf(float.PositiveInfinity), true);
+            TestUtils.AreEqual(isinf(float.NaN), false);
+        }
+
+        [TestCompiler]
+        public static void isinf_float2()
+        {
+            TestUtils.AreEqual(isinf(float2(-float.NaN, float.NegativeInfinity)), bool2(false, true));
+            TestUtils.AreEqual(isinf(float2(float.MinValue, -1f)), bool2(false, false));
+            TestUtils.AreEqual(isinf(float2(0f, 1f)), bool2(false, false));
+            TestUtils.AreEqual(isinf(float2(float.MaxValue, float.PositiveInfinity)), bool2(false, true));
+            TestUtils.AreEqual(isinf(float2(float.NaN, float.NaN)), bool2(false, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_float3()
+        {
+            TestUtils.AreEqual(isinf(float3(-float.NaN, float.NegativeInfinity, float.MinValue)), bool3(false, true, false));
+            TestUtils.AreEqual(isinf(float3(-1f, 0f, 1f)), bool3(false, false, false));
+            TestUtils.AreEqual(isinf(float3(float.MaxValue, float.PositiveInfinity, float.NaN)), bool3(false, true, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_float4()
+        {
+            TestUtils.AreEqual(isinf(float4(-float.NaN, float.NegativeInfinity, float.MinValue, -1f)), bool4(false, true, false, false));
+            TestUtils.AreEqual(isinf(float4(0f, 1f, float.MaxValue, float.PositiveInfinity)), bool4(false, false, false, true));
+            TestUtils.AreEqual(isinf(float4(float.NaN, float.NaN, float.NaN, float.NaN)), bool4(false, false, false, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_double()
+        {
+            TestUtils.AreEqual(isinf(-double.NaN), false);
+            TestUtils.AreEqual(isinf(double.NegativeInfinity), true);
+            TestUtils.AreEqual(isinf(double.MinValue), false);
+            TestUtils.AreEqual(isinf(-1.0), false);
+            TestUtils.AreEqual(isinf(0.0), false);
+            TestUtils.AreEqual(isinf(1.0), false);
+            TestUtils.AreEqual(isinf(double.MaxValue), false);
+            TestUtils.AreEqual(isinf(double.PositiveInfinity), true);
+            TestUtils.AreEqual(isinf(double.NaN), false);
+        }
+
+        [TestCompiler]
+        public static void isinf_double2()
+        {
+            TestUtils.AreEqual(isinf(double2(-double.NaN, double.NegativeInfinity)), bool2(false, true));
+            TestUtils.AreEqual(isinf(double2(double.MinValue, -1.0)), bool2(false, false));
+            TestUtils.AreEqual(isinf(double2(0.0, 1.0)), bool2(false, false));
+            TestUtils.AreEqual(isinf(double2(double.MaxValue, double.PositiveInfinity)), bool2(false, true));
+            TestUtils.AreEqual(isinf(double2(double.NaN, double.NaN)), bool2(false, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_double3()
+        {
+            TestUtils.AreEqual(isinf(double3(-double.NaN, double.NegativeInfinity, double.MinValue)), bool3(false, true, false));
+            TestUtils.AreEqual(isinf(double3(-1.0, 0.0, 1.0)), bool3(false, false, false));
+            TestUtils.AreEqual(isinf(double3(double.MaxValue, double.PositiveInfinity, double.NaN)), bool3(false, true, false));
+        }
+
+        [TestCompiler]
+        public static void isinf_double4()
+        {
+            TestUtils.AreEqual(isinf(double4(-double.NaN, double.NegativeInfinity, double.MinValue, -1.0)), bool4(false, true, false, false));
+            TestUtils.AreEqual(isinf(double4(0.0, 1.0, double.MaxValue, double.PositiveInfinity)), bool4(false, false, false, true));
+            TestUtils.AreEqual(isinf(double4(double.NaN, double.NaN, double.NaN, double.NaN)), bool4(false, false, false, false));
+        }
+
+        [TestCompiler]
+        public static void isnan_float()
+        {
+            TestUtils.AreEqual(isnan(-float.NaN), true);
+            TestUtils.AreEqual(isnan(float.NegativeInfinity), false);
+            TestUtils.AreEqual(isnan(float.MinValue), false);
+            TestUtils.AreEqual(isnan(-1f), false);
+            TestUtils.AreEqual(isnan(0f), false);
+            TestUtils.AreEqual(isnan(1f), false);
+            TestUtils.AreEqual(isnan(float.MaxValue), false);
+            TestUtils.AreEqual(isnan(float.PositiveInfinity), false);
+            TestUtils.AreEqual(isnan(float.NaN), true);
+        }
+
+        [TestCompiler]
+        public static void isnan_float2()
+        {
+            TestUtils.AreEqual(isnan(float2(-float.NaN, float.NegativeInfinity)), bool2(true, false));
+            TestUtils.AreEqual(isnan(float2(float.MinValue, -1f)), bool2(false, false));
+            TestUtils.AreEqual(isnan(float2(0f, 1f)), bool2(false, false));
+            TestUtils.AreEqual(isnan(float2(float.MaxValue, float.PositiveInfinity)), bool2(false, false));
+            TestUtils.AreEqual(isnan(float2(float.NaN, float.NaN)), bool2(true, true));
+        }
+
+        [TestCompiler]
+        public static void isnan_float3()
+        {
+            TestUtils.AreEqual(isnan(float3(-float.NaN, float.NegativeInfinity, float.MinValue)), bool3(true, false, false));
+            TestUtils.AreEqual(isnan(float3(-1f, 0f, 1f)), bool3(false, false, false));
+            TestUtils.AreEqual(isnan(float3(float.MaxValue, float.PositiveInfinity, float.NaN)), bool3(false, false, true));
+        }
+
+        [TestCompiler]
+        public static void isnan_float4()
+        {
+            TestUtils.AreEqual(isnan(float4(-float.NaN, float.NegativeInfinity, float.MinValue, -1f)), bool4(true, false, false, false));
+            TestUtils.AreEqual(isnan(float4(0f, 1f, float.MaxValue, float.PositiveInfinity)), bool4(false, false, false, false));
+            TestUtils.AreEqual(isnan(float4(float.NaN, float.NaN, float.NaN, float.NaN)), bool4(true, true, true, true));
+        }
+
+        [TestCompiler]
+        public static void isnan_double()
+        {
+            TestUtils.AreEqual(isnan(-double.NaN), true);
+            TestUtils.AreEqual(isnan(double.NegativeInfinity), false);
+            TestUtils.AreEqual(isnan(double.MinValue), false);
+            TestUtils.AreEqual(isnan(-1.0), false);
+            TestUtils.AreEqual(isnan(0.0), false);
+            TestUtils.AreEqual(isnan(1.0), false);
+            TestUtils.AreEqual(isnan(double.MaxValue), false);
+            TestUtils.AreEqual(isnan(double.PositiveInfinity), false);
+            TestUtils.AreEqual(isnan(double.NaN), true);
+        }
+
+        [TestCompiler]
+        public static void isnan_double2()
+        {
+            TestUtils.AreEqual(isnan(double2(-double.NaN, double.NegativeInfinity)), bool2(true, false));
+            TestUtils.AreEqual(isnan(double2(double.MinValue, -1.0)), bool2(false, false));
+            TestUtils.AreEqual(isnan(double2(0.0, 1.0)), bool2(false, false));
+            TestUtils.AreEqual(isnan(double2(double.MaxValue, double.PositiveInfinity)), bool2(false, false));
+            TestUtils.AreEqual(isnan(double2(double.NaN, double.NaN)), bool2(true, true));
+        }
+
+        [TestCompiler]
+        public static void isnan_double3()
+        {
+            TestUtils.AreEqual(isnan(double3(-double.NaN, double.NegativeInfinity, double.MinValue)), bool3(true, false, false));
+            TestUtils.AreEqual(isnan(double3(-1.0, 0.0, 1.0)), bool3(false, false, false));
+            TestUtils.AreEqual(isnan(double3(double.MaxValue, double.PositiveInfinity, double.NaN)), bool3(false, false, true));
+        }
+
+        [TestCompiler]
+        public static void isnan_double4()
+        {
+            TestUtils.AreEqual(isnan(double4(-double.NaN, double.NegativeInfinity, double.MinValue, -1.0)), bool4(true, false, false, false));
+            TestUtils.AreEqual(isnan(double4(0.0, 1.0, double.MaxValue, double.PositiveInfinity)), bool4(false, false, false, false));
+            TestUtils.AreEqual(isnan(double4(double.NaN, double.NaN, double.NaN, double.NaN)), bool4(true, true, true, true));
+        }
+
+        [TestCompiler]
+        public static void sin_float()
+        {
+            TestUtils.AreEqual(sin(-1000000f), 0.3499935f, 1, false);
+            TestUtils.AreEqual(sin(-1.2f), -0.9320391f, 1, false);
+            TestUtils.AreEqual(sin(0f), 0f, 1, false);
+            TestUtils.AreEqual(sin(1.2f), 0.9320391f, 1, false);
+            TestUtils.AreEqual(sin(1000000f), -0.3499935f, 1, false);
+            TestUtils.AreEqual(sin(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(sin(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(sin(float.PositiveInfinity), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void sin_float2()
+        {
+            TestUtils.AreEqual(sin(float2(-1000000f, -1.2f)), float2(0.3499935f, -0.9320391f), 1, false);
+            TestUtils.AreEqual(sin(float2(0f, 1.2f)), float2(0f, 0.9320391f), 1, false);
+            TestUtils.AreEqual(sin(float2(1000000f, float.NegativeInfinity)), float2(-0.3499935f, float.NaN), 1, false);
+            TestUtils.AreEqual(sin(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sin_float3()
+        {
+            TestUtils.AreEqual(sin(float3(-1000000f, -1.2f, 0f)), float3(0.3499935f, -0.9320391f, 0f), 1, false);
+            TestUtils.AreEqual(sin(float3(1.2f, 1000000f, float.NegativeInfinity)), float3(0.9320391f, -0.3499935f, float.NaN), 1, false);
+            TestUtils.AreEqual(sin(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sin_float4()
+        {
+            TestUtils.AreEqual(sin(float4(-1000000f, -1.2f, 0f, 1.2f)), float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), 1, false);
+            TestUtils.AreEqual(sin(float4(1000000f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(-0.3499935f, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sin_double()
+        {
+            TestUtils.AreEqual(sin(-1000000.0), 0.34999350217129294, 32, false);
+            TestUtils.AreEqual(sin(-1.2), -0.9320390859672264, 32, false);
+            TestUtils.AreEqual(sin(0.0), 0.0, 32, false);
+            TestUtils.AreEqual(sin(1.2), 0.9320390859672264, 32, false);
+            TestUtils.AreEqual(sin(1000000.0), -0.34999350217129294, 32, false);
+            TestUtils.AreEqual(sin(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(sin(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(sin(double.PositiveInfinity), double.NaN, 32, false);
+        }
+
+        [TestCompiler]
+        public static void sin_double2()
+        {
+            TestUtils.AreEqual(sin(double2(-1000000.0, -1.2)), double2(0.34999350217129294, -0.9320390859672264), 32, false);
+            TestUtils.AreEqual(sin(double2(0.0, 1.2)), double2(0.0, 0.9320390859672264), 32, false);
+            TestUtils.AreEqual(sin(double2(1000000.0, double.NegativeInfinity)), double2(-0.34999350217129294, double.NaN), 32, false);
+            TestUtils.AreEqual(sin(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sin_double3()
+        {
+            TestUtils.AreEqual(sin(double3(-1000000.0, -1.2, 0.0)), double3(0.34999350217129294, -0.9320390859672264, 0.0), 32, false);
+            TestUtils.AreEqual(sin(double3(1.2, 1000000.0, double.NegativeInfinity)), double3(0.9320390859672264, -0.34999350217129294, double.NaN), 32, false);
+            TestUtils.AreEqual(sin(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sin_double4()
+        {
+            TestUtils.AreEqual(sin(double4(-1000000.0, -1.2, 0.0, 1.2)), double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), 32, false);
+            TestUtils.AreEqual(sin(double4(1000000.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(-0.34999350217129294, double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cos_float()
+        {
+            TestUtils.AreEqual(cos(-1000000f), 0.936752141f, 8, false);
+            TestUtils.AreEqual(cos(-1.2f), 0.362357765f, 8, false);
+            TestUtils.AreEqual(cos(0f), 1f, 8, false);
+            TestUtils.AreEqual(cos(1.2f), 0.362357765f, 8, false);
+            TestUtils.AreEqual(cos(1000000f), 0.936752141f, 8, false);
+            TestUtils.AreEqual(cos(float.NegativeInfinity), float.NaN, 8, false);
+            TestUtils.AreEqual(cos(float.NaN), float.NaN, 8, false);
+            TestUtils.AreEqual(cos(float.PositiveInfinity), float.NaN, 8, false);
+        }
+
+        [TestCompiler]
+        public static void cos_float2()
+        {
+            TestUtils.AreEqual(cos(float2(-1000000f, -1.2f)), float2(0.936752141f, 0.362357765f), 8, false);
+            TestUtils.AreEqual(cos(float2(0f, 1.2f)), float2(1f, 0.362357765f), 8, false);
+            TestUtils.AreEqual(cos(float2(1000000f, float.NegativeInfinity)), float2(0.936752141f, float.NaN), 8, false);
+            TestUtils.AreEqual(cos(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void cos_float3()
+        {
+            TestUtils.AreEqual(cos(float3(-1000000f, -1.2f, 0f)), float3(0.936752141f, 0.362357765f, 1f), 8, false);
+            TestUtils.AreEqual(cos(float3(1.2f, 1000000f, float.NegativeInfinity)), float3(0.362357765f, 0.936752141f, float.NaN), 8, false);
+            TestUtils.AreEqual(cos(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void cos_float4()
+        {
+            TestUtils.AreEqual(cos(float4(-1000000f, -1.2f, 0f, 1.2f)), float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), 8, false);
+            TestUtils.AreEqual(cos(float4(1000000f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(0.936752141f, float.NaN, float.NaN, float.NaN), 8, false);
+        }
+
+        [TestCompiler]
+        public static void cos_double()
+        {
+            TestUtils.AreEqual(cos(-1000000.0), 0.93675212753314474, 32, false);
+            TestUtils.AreEqual(cos(-1.2), 0.36235775447667357, 32, false);
+            TestUtils.AreEqual(cos(0.0), 1.0, 32, false);
+            TestUtils.AreEqual(cos(1.2), 0.36235775447667357, 32, false);
+            TestUtils.AreEqual(cos(1000000.0), 0.93675212753314474, 32, false);
+            TestUtils.AreEqual(cos(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(cos(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(cos(double.PositiveInfinity), double.NaN, 32, false);
+        }
+
+        [TestCompiler]
+        public static void cos_double2()
+        {
+            TestUtils.AreEqual(cos(double2(-1000000.0, -1.2)), double2(0.93675212753314474, 0.36235775447667357), 32, false);
+            TestUtils.AreEqual(cos(double2(0.0, 1.2)), double2(1.0, 0.36235775447667357), 32, false);
+            TestUtils.AreEqual(cos(double2(1000000.0, double.NegativeInfinity)), double2(0.93675212753314474, double.NaN), 32, false);
+            TestUtils.AreEqual(cos(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cos_double3()
+        {
+            TestUtils.AreEqual(cos(double3(-1000000.0, -1.2, 0.0)), double3(0.93675212753314474, 0.36235775447667357, 1.0), 32, false);
+            TestUtils.AreEqual(cos(double3(1.2, 1000000.0, double.NegativeInfinity)), double3(0.36235775447667357, 0.93675212753314474, double.NaN), 32, false);
+            TestUtils.AreEqual(cos(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cos_double4()
+        {
+            TestUtils.AreEqual(cos(double4(-1000000.0, -1.2, 0.0, 1.2)), double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), 32, false);
+            TestUtils.AreEqual(cos(double4(1000000.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tan_float()
+        {
+            TestUtils.AreEqual(tan(-1000000f), 0.373624444f, 1, false);
+            TestUtils.AreEqual(tan(-1.2f), -2.57215166f, 1, false);
+            TestUtils.AreEqual(tan(0f), 0f, 1, false);
+            TestUtils.AreEqual(tan(1.2f), 2.57215166f, 1, false);
+            TestUtils.AreEqual(tan(1000000f), -0.373624444f, 1, false);
+            TestUtils.AreEqual(tan(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(tan(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(tan(float.PositiveInfinity), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void tan_float2()
+        {
+            TestUtils.AreEqual(tan(float2(-1000000f, -1.2f)), float2(0.373624444f, -2.57215166f), 1, false);
+            TestUtils.AreEqual(tan(float2(0f, 1.2f)), float2(0f, 2.57215166f), 1, false);
+            TestUtils.AreEqual(tan(float2(1000000f, float.NegativeInfinity)), float2(-0.373624444f, float.NaN), 1, false);
+            TestUtils.AreEqual(tan(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tan_float3()
+        {
+            TestUtils.AreEqual(tan(float3(-1000000f, -1.2f, 0f)), float3(0.373624444f, -2.57215166f, 0f), 1, false);
+            TestUtils.AreEqual(tan(float3(1.2f, 1000000f, float.NegativeInfinity)), float3(2.57215166f, -0.373624444f, float.NaN), 1, false);
+            TestUtils.AreEqual(tan(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tan_float4()
+        {
+            TestUtils.AreEqual(tan(float4(-1000000f, -1.2f, 0f, 1.2f)), float4(0.373624444f, -2.57215166f, 0f, 2.57215166f), 1, false);
+            TestUtils.AreEqual(tan(float4(1000000f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(-0.373624444f, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tan_double()
+        {
+            TestUtils.AreEqual(tan(-1000000.0), 0.373624453987599, 32, false);
+            TestUtils.AreEqual(tan(-1.2), -2.57215162212632, 32, false);
+            TestUtils.AreEqual(tan(0.0), 0.0, 32, false);
+            TestUtils.AreEqual(tan(1.2), 2.57215162212632, 32, false);
+            TestUtils.AreEqual(tan(1000000.0), -0.373624453987599, 32, false);
+            TestUtils.AreEqual(tan(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(tan(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(tan(double.PositiveInfinity), double.NaN, 32, false);
+        }
+
+        [TestCompiler]
+        public static void tan_double2()
+        {
+            TestUtils.AreEqual(tan(double2(-1000000.0, -1.2)), double2(0.373624453987599, -2.57215162212632), 32, false);
+            TestUtils.AreEqual(tan(double2(0.0, 1.2)), double2(0.0, 2.57215162212632), 32, false);
+            TestUtils.AreEqual(tan(double2(1000000.0, double.NegativeInfinity)), double2(-0.373624453987599, double.NaN), 32, false);
+            TestUtils.AreEqual(tan(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tan_double3()
+        {
+            TestUtils.AreEqual(tan(double3(-1000000.0, -1.2, 0.0)), double3(0.373624453987599, -2.57215162212632, 0.0), 32, false);
+            TestUtils.AreEqual(tan(double3(1.2, 1000000.0, double.NegativeInfinity)), double3(2.57215162212632, -0.373624453987599, double.NaN), 32, false);
+            TestUtils.AreEqual(tan(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tan_double4()
+        {
+            TestUtils.AreEqual(tan(double4(-1000000.0, -1.2, 0.0, 1.2)), double4(0.373624453987599, -2.57215162212632, 0.0, 2.57215162212632), 32, false);
+            TestUtils.AreEqual(tan(double4(1000000.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(-0.373624453987599, double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan_float()
+        {
+            TestUtils.AreEqual(atan(-1000000f), -1.5707953f, 1, false);
+            TestUtils.AreEqual(atan(-1.2f), -0.876058042f, 1, false);
+            TestUtils.AreEqual(atan(0f), 0f, 1, false);
+            TestUtils.AreEqual(atan(1.2f), 0.876058042f, 1, false);
+            TestUtils.AreEqual(atan(1000000f), 1.5707953f, 1, false);
+            TestUtils.AreEqual(atan(float.NegativeInfinity), -1.57079637f, 1, false);
+            TestUtils.AreEqual(atan(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(atan(float.PositiveInfinity), 1.57079637f, 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan_float2()
+        {
+            TestUtils.AreEqual(atan(float2(-1000000f, -1.2f)), float2(-1.5707953f, -0.876058042f), 1, false);
+            TestUtils.AreEqual(atan(float2(0f, 1.2f)), float2(0f, 0.876058042f), 1, false);
+            TestUtils.AreEqual(atan(float2(1000000f, float.NegativeInfinity)), float2(1.5707953f, -1.57079637f), 1, false);
+            TestUtils.AreEqual(atan(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, 1.57079637f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan_float3()
+        {
+            TestUtils.AreEqual(atan(float3(-1000000f, -1.2f, 0f)), float3(-1.5707953f, -0.876058042f, 0f), 1, false);
+            TestUtils.AreEqual(atan(float3(1.2f, 1000000f, float.NegativeInfinity)), float3(0.876058042f, 1.5707953f, -1.57079637f), 1, false);
+            TestUtils.AreEqual(atan(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, 1.57079637f, 1.57079637f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan_float4()
+        {
+            TestUtils.AreEqual(atan(float4(-1000000f, -1.2f, 0f, 1.2f)), float4(-1.5707953f, -0.876058042f, 0f, 0.876058042f), 1, false);
+            TestUtils.AreEqual(atan(float4(1000000f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(1.5707953f, -1.57079637f, float.NaN, 1.57079637f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan_double()
+        {
+            TestUtils.AreEqual(atan(-1000000.0), -1.5707953267948971, 32, false);
+            TestUtils.AreEqual(atan(-1.2), -0.87605805059819342, 32, false);
+            TestUtils.AreEqual(atan(0.0), 0.0, 32, false);
+            TestUtils.AreEqual(atan(1.2), 0.87605805059819342, 32, false);
+            TestUtils.AreEqual(atan(1000000.0), 1.5707953267948971, 32, false);
+            TestUtils.AreEqual(atan(double.NegativeInfinity), -1.570796326794897, 32, false);
+            TestUtils.AreEqual(atan(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(atan(double.PositiveInfinity), 1.570796326794897, 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan_double2()
+        {
+            TestUtils.AreEqual(atan(double2(-1000000.0, -1.2)), double2(-1.5707953267948971, -0.87605805059819342), 32, false);
+            TestUtils.AreEqual(atan(double2(0.0, 1.2)), double2(0.0, 0.87605805059819342), 32, false);
+            TestUtils.AreEqual(atan(double2(1000000.0, double.NegativeInfinity)), double2(1.5707953267948971, -1.570796326794897), 32, false);
+            TestUtils.AreEqual(atan(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, 1.570796326794897), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan_double3()
+        {
+            TestUtils.AreEqual(atan(double3(-1000000.0, -1.2, 0.0)), double3(-1.5707953267948971, -0.87605805059819342, 0.0), 32, false);
+            TestUtils.AreEqual(atan(double3(1.2, 1000000.0, double.NegativeInfinity)), double3(0.87605805059819342, 1.5707953267948971, -1.570796326794897), 32, false);
+            TestUtils.AreEqual(atan(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, 1.570796326794897, 1.570796326794897), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan_double4()
+        {
+            TestUtils.AreEqual(atan(double4(-1000000.0, -1.2, 0.0, 1.2)), double4(-1.5707953267948971, -0.87605805059819342, 0.0, 0.87605805059819342), 32, false);
+            TestUtils.AreEqual(atan(double4(1000000.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(1.5707953267948971, -1.570796326794897, double.NaN, 1.570796326794897), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_float()
+        {
+            TestUtils.AreEqual(atan2(3.1f, 2.4f), 0.9119903f, 1, false);
+            TestUtils.AreEqual(atan2(3.1f, -2.4f), 2.22960234f, 1, false);
+            TestUtils.AreEqual(atan2(-3.1f, 2.4f), -0.9119903f, 1, false);
+            TestUtils.AreEqual(atan2(-3.1f, -2.4f), -2.22960234f, 1, false);
+            TestUtils.AreEqual(atan2(0f, 0f), 0f, 1, false);
+            TestUtils.AreEqual(atan2(1f, float.NegativeInfinity), 3.14159274f, 1, false);
+            TestUtils.AreEqual(atan2(1f, float.PositiveInfinity), 0f, 1, false);
+            TestUtils.AreEqual(atan2(float.NegativeInfinity, 1f), -1.57079637f, 1, false);
+            TestUtils.AreEqual(atan2(float.PositiveInfinity, 1f), 1.57079637f, 1, false);
+            TestUtils.AreEqual(atan2(1f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(atan2(float.NaN, 1f), float.NaN, 1, false);
+            TestUtils.AreEqual(atan2(float.NaN, float.NaN), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_float2()
+        {
+            TestUtils.AreEqual(atan2(float2(3.1f, 3.1f), float2(2.4f, -2.4f)), float2(0.9119903f, 2.22960234f), 1, false);
+            TestUtils.AreEqual(atan2(float2(-3.1f, -3.1f), float2(2.4f, -2.4f)), float2(-0.9119903f, -2.22960234f), 1, false);
+            TestUtils.AreEqual(atan2(float2(0f, 1f), float2(0f, float.NegativeInfinity)), float2(0f, 3.14159274f), 1, false);
+            TestUtils.AreEqual(atan2(float2(1f, float.NegativeInfinity), float2(float.PositiveInfinity, 1f)), float2(0f, -1.57079637f), 1, false);
+            TestUtils.AreEqual(atan2(float2(float.PositiveInfinity, 1f), float2(1f, float.NaN)), float2(1.57079637f, float.NaN), 1, false);
+            TestUtils.AreEqual(atan2(float2(float.NaN, float.NaN), float2(1f, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_float3()
+        {
+            TestUtils.AreEqual(atan2(float3(3.1f, 3.1f, -3.1f), float3(2.4f, -2.4f, 2.4f)), float3(0.9119903f, 2.22960234f, -0.9119903f), 1, false);
+            TestUtils.AreEqual(atan2(float3(-3.1f, 0f, 1f), float3(-2.4f, 0f, float.NegativeInfinity)), float3(-2.22960234f, 0f, 3.14159274f), 1, false);
+            TestUtils.AreEqual(atan2(float3(1f, float.NegativeInfinity, float.PositiveInfinity), float3(float.PositiveInfinity, 1f, 1f)), float3(0f, -1.57079637f, 1.57079637f), 1, false);
+            TestUtils.AreEqual(atan2(float3(1f, float.NaN, float.NaN), float3(float.NaN, 1f, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_float4()
+        {
+            TestUtils.AreEqual(atan2(float4(3.1f, 3.1f, -3.1f, -3.1f), float4(2.4f, -2.4f, 2.4f, -2.4f)), float4(0.9119903f, 2.22960234f, -0.9119903f, -2.22960234f), 1, false);
+            TestUtils.AreEqual(atan2(float4(0f, 1f, 1f, float.NegativeInfinity), float4(0f, float.NegativeInfinity, float.PositiveInfinity, 1f)), float4(0f, 3.14159274f, 0f, -1.57079637f), 1, false);
+            TestUtils.AreEqual(atan2(float4(float.PositiveInfinity, 1f, float.NaN, float.NaN), float4(1f, float.NaN, 1f, float.NaN)), float4(1.57079637f, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_double()
+        {
+            TestUtils.AreEqual(atan2(3.1, 2.4), 0.91199029067742043, 32, false);
+            TestUtils.AreEqual(atan2(3.1, -2.4), 2.2296023629123729, 32, false);
+            TestUtils.AreEqual(atan2(-3.1, 2.4), -0.91199029067742043, 32, false);
+            TestUtils.AreEqual(atan2(-3.1, -2.4), -2.2296023629123729, 32, false);
+            TestUtils.AreEqual(atan2(0.0, 0.0), 0.0, 32, false);
+            TestUtils.AreEqual(atan2(1.0, double.NegativeInfinity), 3.1415926535897931, 32, false);
+            TestUtils.AreEqual(atan2(1.0, double.PositiveInfinity), 0.0, 32, false);
+            TestUtils.AreEqual(atan2(double.NegativeInfinity, 1.0), -1.5707963267948966, 32, false);
+            TestUtils.AreEqual(atan2(double.PositiveInfinity, 1.0), 1.5707963267948966, 32, false);
+            TestUtils.AreEqual(atan2(1.0, double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(atan2(double.NaN, 1.0), double.NaN, 32, false);
+            TestUtils.AreEqual(atan2(double.NaN, double.NaN), double.NaN, 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_double2()
+        {
+            TestUtils.AreEqual(atan2(double2(3.1, 3.1), double2(2.4, -2.4)), double2(0.91199029067742043, 2.2296023629123729), 32, false);
+            TestUtils.AreEqual(atan2(double2(-3.1, -3.1), double2(2.4, -2.4)), double2(-0.91199029067742043, -2.2296023629123729), 32, false);
+            TestUtils.AreEqual(atan2(double2(0.0, 1.0), double2(0.0, double.NegativeInfinity)), double2(0.0, 3.1415926535897931), 32, false);
+            TestUtils.AreEqual(atan2(double2(1.0, double.NegativeInfinity), double2(double.PositiveInfinity, 1.0)), double2(0.0, -1.5707963267948966), 32, false);
+            TestUtils.AreEqual(atan2(double2(double.PositiveInfinity, 1.0), double2(1.0, double.NaN)), double2(1.5707963267948966, double.NaN), 32, false);
+            TestUtils.AreEqual(atan2(double2(double.NaN, double.NaN), double2(1.0, double.NaN)), double2(double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_double3()
+        {
+            TestUtils.AreEqual(atan2(double3(3.1, 3.1, -3.1), double3(2.4, -2.4, 2.4)), double3(0.91199029067742043, 2.2296023629123729, -0.91199029067742043), 32, false);
+            TestUtils.AreEqual(atan2(double3(-3.1, 0.0, 1.0), double3(-2.4, 0.0, double.NegativeInfinity)), double3(-2.2296023629123729, 0.0, 3.1415926535897931), 32, false);
+            TestUtils.AreEqual(atan2(double3(1.0, double.NegativeInfinity, double.PositiveInfinity), double3(double.PositiveInfinity, 1.0, 1.0)), double3(0.0, -1.5707963267948966, 1.5707963267948966), 32, false);
+            TestUtils.AreEqual(atan2(double3(1.0, double.NaN, double.NaN), double3(double.NaN, 1.0, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void atan2_double4()
+        {
+            TestUtils.AreEqual(atan2(double4(3.1, 3.1, -3.1, -3.1), double4(2.4, -2.4, 2.4, -2.4)), double4(0.91199029067742043, 2.2296023629123729, -0.91199029067742043, -2.2296023629123729), 32, false);
+            TestUtils.AreEqual(atan2(double4(0.0, 1.0, 1.0, double.NegativeInfinity), double4(0.0, double.NegativeInfinity, double.PositiveInfinity, 1.0)), double4(0.0, 3.1415926535897931, 0.0, -1.5707963267948966), 32, false);
+            TestUtils.AreEqual(atan2(double4(double.PositiveInfinity, 1.0, double.NaN, double.NaN), double4(1.0, double.NaN, 1.0, double.NaN)), double4(1.5707963267948966, double.NaN, double.NaN, double.NaN), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_float()
+        {
+            TestUtils.AreEqual(sinh(-2f), -3.62686038f, 1, false);
+            TestUtils.AreEqual(sinh(-1.2f), -1.5094614f, 1, false);
+            TestUtils.AreEqual(sinh(0f), 0f, 1, false);
+            TestUtils.AreEqual(sinh(1.2f), 1.5094614f, 1, false);
+            TestUtils.AreEqual(sinh(2f), 3.62686038f, 1, false);
+            TestUtils.AreEqual(sinh(float.NegativeInfinity), float.NegativeInfinity, 1, false);
+            TestUtils.AreEqual(sinh(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(sinh(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_float2()
+        {
+            TestUtils.AreEqual(sinh(float2(-2f, -1.2f)), float2(-3.62686038f, -1.5094614f), 1, false);
+            TestUtils.AreEqual(sinh(float2(0f, 1.2f)), float2(0f, 1.5094614f), 1, false);
+            TestUtils.AreEqual(sinh(float2(2f, float.NegativeInfinity)), float2(3.62686038f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(sinh(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_float3()
+        {
+            TestUtils.AreEqual(sinh(float3(-2f, -1.2f, 0f)), float3(-3.62686038f, -1.5094614f, 0f), 1, false);
+            TestUtils.AreEqual(sinh(float3(1.2f, 2f, float.NegativeInfinity)), float3(1.5094614f, 3.62686038f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(sinh(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_float4()
+        {
+            TestUtils.AreEqual(sinh(float4(-2f, -1.2f, 0f, 1.2f)), float4(-3.62686038f, -1.5094614f, 0f, 1.5094614f), 1, false);
+            TestUtils.AreEqual(sinh(float4(2f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(3.62686038f, float.NegativeInfinity, float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_double()
+        {
+            TestUtils.AreEqual(sinh(-2.0), -3.6268604078470181, 32, false);
+            TestUtils.AreEqual(sinh(-1.2), -1.509461355412173, 32, false);
+            TestUtils.AreEqual(sinh(0.0), 0.0, 32, false);
+            TestUtils.AreEqual(sinh(1.2), 1.509461355412173, 32, false);
+            TestUtils.AreEqual(sinh(2.0), 3.6268604078470181, 32, false);
+            TestUtils.AreEqual(sinh(double.NegativeInfinity), double.NegativeInfinity, 32, false);
+            TestUtils.AreEqual(sinh(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(sinh(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_double2()
+        {
+            TestUtils.AreEqual(sinh(double2(-2.0, -1.2)), double2(-3.6268604078470181, -1.509461355412173), 32, false);
+            TestUtils.AreEqual(sinh(double2(0.0, 1.2)), double2(0.0, 1.509461355412173), 32, false);
+            TestUtils.AreEqual(sinh(double2(2.0, double.NegativeInfinity)), double2(3.6268604078470181, double.NegativeInfinity), 32, false);
+            TestUtils.AreEqual(sinh(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_double3()
+        {
+            TestUtils.AreEqual(sinh(double3(-2.0, -1.2, 0.0)), double3(-3.6268604078470181, -1.509461355412173, 0.0), 32, false);
+            TestUtils.AreEqual(sinh(double3(1.2, 2.0, double.NegativeInfinity)), double3(1.509461355412173, 3.6268604078470181, double.NegativeInfinity), 32, false);
+            TestUtils.AreEqual(sinh(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void sinh_double4()
+        {
+            TestUtils.AreEqual(sinh(double4(-2.0, -1.2, 0.0, 1.2)), double4(-3.6268604078470181, -1.509461355412173, 0.0, 1.509461355412173), 32, false);
+            TestUtils.AreEqual(sinh(double4(2.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(3.6268604078470181, double.NegativeInfinity, double.NaN, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_float()
+        {
+            TestUtils.AreEqual(cosh(-2f), 3.76219559f, 1, false);
+            TestUtils.AreEqual(cosh(-1.2f), 1.81065559f, 1, false);
+            TestUtils.AreEqual(cosh(0f), 1f, 1, false);
+            TestUtils.AreEqual(cosh(1.2f), 1.81065559f, 1, false);
+            TestUtils.AreEqual(cosh(2f), 3.76219559f, 1, false);
+            TestUtils.AreEqual(cosh(float.NegativeInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(cosh(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(cosh(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_float2()
+        {
+            TestUtils.AreEqual(cosh(float2(-2f, -1.2f)), float2(3.76219559f, 1.81065559f), 1, false);
+            TestUtils.AreEqual(cosh(float2(0f, 1.2f)), float2(1f, 1.81065559f), 1, false);
+            TestUtils.AreEqual(cosh(float2(2f, float.NegativeInfinity)), float2(3.76219559f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(cosh(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_float3()
+        {
+            TestUtils.AreEqual(cosh(float3(-2f, -1.2f, 0f)), float3(3.76219559f, 1.81065559f, 1f), 1, false);
+            TestUtils.AreEqual(cosh(float3(1.2f, 2f, float.NegativeInfinity)), float3(1.81065559f, 3.76219559f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(cosh(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_float4()
+        {
+            TestUtils.AreEqual(cosh(float4(-2f, -1.2f, 0f, 1.2f)), float4(3.76219559f, 1.81065559f, 1f, 1.81065559f), 1, false);
+            TestUtils.AreEqual(cosh(float4(2f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(3.76219559f, float.PositiveInfinity, float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_double()
+        {
+            TestUtils.AreEqual(cosh(-2.0), 3.7621956910836314, 32, false);
+            TestUtils.AreEqual(cosh(-1.2), 1.81065556732437, 32, false);
+            TestUtils.AreEqual(cosh(0.0), 1.0, 32, false);
+            TestUtils.AreEqual(cosh(1.2), 1.81065556732437, 32, false);
+            TestUtils.AreEqual(cosh(2.0), 3.7621956910836314, 32, false);
+            TestUtils.AreEqual(cosh(double.NegativeInfinity), double.PositiveInfinity, 32, false);
+            TestUtils.AreEqual(cosh(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(cosh(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_double2()
+        {
+            TestUtils.AreEqual(cosh(double2(-2.0, -1.2)), double2(3.7621956910836314, 1.81065556732437), 32, false);
+            TestUtils.AreEqual(cosh(double2(0.0, 1.2)), double2(1.0, 1.81065556732437), 32, false);
+            TestUtils.AreEqual(cosh(double2(2.0, double.NegativeInfinity)), double2(3.7621956910836314, double.PositiveInfinity), 32, false);
+            TestUtils.AreEqual(cosh(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_double3()
+        {
+            TestUtils.AreEqual(cosh(double3(-2.0, -1.2, 0.0)), double3(3.7621956910836314, 1.81065556732437, 1.0), 32, false);
+            TestUtils.AreEqual(cosh(double3(1.2, 2.0, double.NegativeInfinity)), double3(1.81065556732437, 3.7621956910836314, double.PositiveInfinity), 32, false);
+            TestUtils.AreEqual(cosh(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void cosh_double4()
+        {
+            TestUtils.AreEqual(cosh(double4(-2.0, -1.2, 0.0, 1.2)), double4(3.7621956910836314, 1.81065556732437, 1.0, 1.81065556732437), 32, false);
+            TestUtils.AreEqual(cosh(double4(2.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(3.7621956910836314, double.PositiveInfinity, double.NaN, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_float()
+        {
+            TestUtils.AreEqual(tanh(-2f), -0.9640276f, 1, false);
+            TestUtils.AreEqual(tanh(-1.2f), -0.8336546f, 1, false);
+            TestUtils.AreEqual(tanh(0f), 0f, 1, false);
+            TestUtils.AreEqual(tanh(1.2f), 0.8336546f, 1, false);
+            TestUtils.AreEqual(tanh(2f), 0.9640276f, 1, false);
+            TestUtils.AreEqual(tanh(float.NegativeInfinity), -1f, 1, false);
+            TestUtils.AreEqual(tanh(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(tanh(float.PositiveInfinity), 1f, 1, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_float2()
+        {
+            TestUtils.AreEqual(tanh(float2(-2f, -1.2f)), float2(-0.9640276f, -0.8336546f), 1, false);
+            TestUtils.AreEqual(tanh(float2(0f, 1.2f)), float2(0f, 0.8336546f), 1, false);
+            TestUtils.AreEqual(tanh(float2(2f, float.NegativeInfinity)), float2(0.9640276f, -1f), 1, false);
+            TestUtils.AreEqual(tanh(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, 1f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_float3()
+        {
+            TestUtils.AreEqual(tanh(float3(-2f, -1.2f, 0f)), float3(-0.9640276f, -0.8336546f, 0f), 1, false);
+            TestUtils.AreEqual(tanh(float3(1.2f, 2f, float.NegativeInfinity)), float3(0.8336546f, 0.9640276f, -1f), 1, false);
+            TestUtils.AreEqual(tanh(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, 1f, 1f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_float4()
+        {
+            TestUtils.AreEqual(tanh(float4(-2f, -1.2f, 0f, 1.2f)), float4(-0.9640276f, -0.8336546f, 0f, 0.8336546f), 1, false);
+            TestUtils.AreEqual(tanh(float4(2f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(0.9640276f, -1f, float.NaN, 1f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_double()
+        {
+            TestUtils.AreEqual(tanh(-2.0), -0.9640275800758169, 32, false);
+            TestUtils.AreEqual(tanh(-1.2), -0.83365460701215521, 32, false);
+            TestUtils.AreEqual(tanh(0.0), 0.0, 32, false);
+            TestUtils.AreEqual(tanh(1.2), 0.83365460701215521, 32, false);
+            TestUtils.AreEqual(tanh(2.0), 0.9640275800758169, 32, false);
+            TestUtils.AreEqual(tanh(double.NegativeInfinity), -1.0, 32, false);
+            TestUtils.AreEqual(tanh(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(tanh(double.PositiveInfinity), 1.0, 32, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_double2()
+        {
+            TestUtils.AreEqual(tanh(double2(-2.0, -1.2)), double2(-0.9640275800758169, -0.83365460701215521), 32, false);
+            TestUtils.AreEqual(tanh(double2(0.0, 1.2)), double2(0.0, 0.83365460701215521), 32, false);
+            TestUtils.AreEqual(tanh(double2(2.0, double.NegativeInfinity)), double2(0.9640275800758169, -1.0), 32, false);
+            TestUtils.AreEqual(tanh(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, 1.0), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_double3()
+        {
+            TestUtils.AreEqual(tanh(double3(-2.0, -1.2, 0.0)), double3(-0.9640275800758169, -0.83365460701215521, 0.0), 32, false);
+            TestUtils.AreEqual(tanh(double3(1.2, 2.0, double.NegativeInfinity)), double3(0.83365460701215521, 0.9640275800758169, -1.0), 32, false);
+            TestUtils.AreEqual(tanh(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, 1.0, 1.0), 32, false);
+        }
+
+        [TestCompiler]
+        public static void tanh_double4()
+        {
+            TestUtils.AreEqual(tanh(double4(-2.0, -1.2, 0.0, 1.2)), double4(-0.9640275800758169, -0.83365460701215521, 0.0, 0.83365460701215521), 32, false);
+            TestUtils.AreEqual(tanh(double4(2.0, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(0.9640275800758169, -1.0, double.NaN, 1.0), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp_float()
+        {
+            TestUtils.AreEqual(exp(-10f), 4.539993E-05f, 1, false);
+            TestUtils.AreEqual(exp(-1.2f), 0.301194221f, 1, false);
+            TestUtils.AreEqual(exp(0f), 1f, 1, false);
+            TestUtils.AreEqual(exp(1.2f), 3.320117f, 1, false);
+            TestUtils.AreEqual(exp(float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(exp(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(exp(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp_float2()
+        {
+            TestUtils.AreEqual(exp(float2(-10f, -1.2f)), float2(4.539993E-05f, 0.301194221f), 1, false);
+            TestUtils.AreEqual(exp(float2(0f, 1.2f)), float2(1f, 3.320117f), 1, false);
+            TestUtils.AreEqual(exp(float2(float.NegativeInfinity, float.NaN)), float2(0f, float.NaN), 1, false);
+            TestUtils.AreEqual(exp(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp_float3()
+        {
+            TestUtils.AreEqual(exp(float3(-10f, -1.2f, 0f)), float3(4.539993E-05f, 0.301194221f, 1f), 1, false);
+            TestUtils.AreEqual(exp(float3(1.2f, float.NegativeInfinity, float.NaN)), float3(3.320117f, 0f, float.NaN), 1, false);
+            TestUtils.AreEqual(exp(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp_float4()
+        {
+            TestUtils.AreEqual(exp(float4(-10f, -1.2f, 0f, 1.2f)), float4(4.539993E-05f, 0.301194221f, 1f, 3.320117f), 1, false);
+            TestUtils.AreEqual(exp(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(0f, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp_double()
+        {
+            TestUtils.AreEqual(exp(-10.0), 4.5399929762484847E-05, 32, false);
+            TestUtils.AreEqual(exp(-1.2), 0.30119421191220208, 32, false);
+            TestUtils.AreEqual(exp(0.0), 1.0, 32, false);
+            TestUtils.AreEqual(exp(1.2), 3.3201169227365477, 32, false);
+            TestUtils.AreEqual(exp(double.NegativeInfinity), 0.0, 32, false);
+            TestUtils.AreEqual(exp(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(exp(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp_double2()
+        {
+            TestUtils.AreEqual(exp(double2(-10.0, -1.2)), double2(4.5399929762484847E-05, 0.30119421191220208), 32, false);
+            TestUtils.AreEqual(exp(double2(0.0, 1.2)), double2(1.0, 3.3201169227365477), 32, false);
+            TestUtils.AreEqual(exp(double2(double.NegativeInfinity, double.NaN)), double2(0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp_double3()
+        {
+            TestUtils.AreEqual(exp(double3(-10.0, -1.2, 0.0)), double3(4.5399929762484847E-05, 0.30119421191220208, 1.0), 32, false);
+            TestUtils.AreEqual(exp(double3(1.2, double.NegativeInfinity, double.NaN)), double3(3.3201169227365477, 0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp_double4()
+        {
+            TestUtils.AreEqual(exp(double4(-10.0, -1.2, 0.0, 1.2)), double4(4.5399929762484847E-05, 0.30119421191220208, 1.0, 3.3201169227365477), 32, false);
+            TestUtils.AreEqual(exp(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(0.0, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_float()
+        {
+            TestUtils.AreEqual(exp2(-10f), 0.0009765625f, 1, false);
+            TestUtils.AreEqual(exp2(-1.2f), 0.4352753f, 1, false);
+            TestUtils.AreEqual(exp2(0f), 1f, 1, false);
+            TestUtils.AreEqual(exp2(1.2f), 2.29739666f, 1, false);
+            TestUtils.AreEqual(exp2(float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(exp2(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(exp2(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_float2()
+        {
+            TestUtils.AreEqual(exp2(float2(-10f, -1.2f)), float2(0.0009765625f, 0.4352753f), 1, false);
+            TestUtils.AreEqual(exp2(float2(0f, 1.2f)), float2(1f, 2.29739666f), 1, false);
+            TestUtils.AreEqual(exp2(float2(float.NegativeInfinity, float.NaN)), float2(0f, float.NaN), 1, false);
+            TestUtils.AreEqual(exp2(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_float3()
+        {
+            TestUtils.AreEqual(exp2(float3(-10f, -1.2f, 0f)), float3(0.0009765625f, 0.4352753f, 1f), 1, false);
+            TestUtils.AreEqual(exp2(float3(1.2f, float.NegativeInfinity, float.NaN)), float3(2.29739666f, 0f, float.NaN), 1, false);
+            TestUtils.AreEqual(exp2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_float4()
+        {
+            TestUtils.AreEqual(exp2(float4(-10f, -1.2f, 0f, 1.2f)), float4(0.0009765625f, 0.4352753f, 1f, 2.29739666f), 1, false);
+            TestUtils.AreEqual(exp2(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(0f, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_double()
+        {
+            TestUtils.AreEqual(exp2(-10.0), 0.0009765625, 32, false);
+            TestUtils.AreEqual(exp2(-1.2), 0.435275281648062, 32, false);
+            TestUtils.AreEqual(exp2(0.0), 1.0, 32, false);
+            TestUtils.AreEqual(exp2(1.2), 2.29739670999407, 32, false);
+            TestUtils.AreEqual(exp2(double.NegativeInfinity), 0.0, 32, false);
+            TestUtils.AreEqual(exp2(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(exp2(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_double2()
+        {
+            TestUtils.AreEqual(exp2(double2(-10.0, -1.2)), double2(0.0009765625, 0.435275281648062), 32, false);
+            TestUtils.AreEqual(exp2(double2(0.0, 1.2)), double2(1.0, 2.29739670999407), 32, false);
+            TestUtils.AreEqual(exp2(double2(double.NegativeInfinity, double.NaN)), double2(0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp2(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_double3()
+        {
+            TestUtils.AreEqual(exp2(double3(-10.0, -1.2, 0.0)), double3(0.0009765625, 0.435275281648062, 1.0), 32, false);
+            TestUtils.AreEqual(exp2(double3(1.2, double.NegativeInfinity, double.NaN)), double3(2.29739670999407, 0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp2_double4()
+        {
+            TestUtils.AreEqual(exp2(double4(-10.0, -1.2, 0.0, 1.2)), double4(0.0009765625, 0.435275281648062, 1.0, 2.29739670999407), 32, false);
+            TestUtils.AreEqual(exp2(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(0.0, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_float()
+        {
+            TestUtils.AreEqual(exp10(-10f), 1E-10f, 32, false);
+            TestUtils.AreEqual(exp10(-1.2f), 0.06309573f, 32, false);
+            TestUtils.AreEqual(exp10(0f), 1f, 32, false);
+            TestUtils.AreEqual(exp10(1.2f), 15.8489323f, 32, false);
+            TestUtils.AreEqual(exp10(float.NegativeInfinity), 0f, 32, false);
+            TestUtils.AreEqual(exp10(float.NaN), float.NaN, 32, false);
+            TestUtils.AreEqual(exp10(float.PositiveInfinity), float.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_float2()
+        {
+            TestUtils.AreEqual(exp10(float2(-10f, -1.2f)), float2(1E-10f, 0.06309573f), 32, false);
+            TestUtils.AreEqual(exp10(float2(0f, 1.2f)), float2(1f, 15.8489323f), 32, false);
+            TestUtils.AreEqual(exp10(float2(float.NegativeInfinity, float.NaN)), float2(0f, float.NaN), 32, false);
+            TestUtils.AreEqual(exp10(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_float3()
+        {
+            TestUtils.AreEqual(exp10(float3(-10f, -1.2f, 0f)), float3(1E-10f, 0.06309573f, 1f), 32, false);
+            TestUtils.AreEqual(exp10(float3(1.2f, float.NegativeInfinity, float.NaN)), float3(15.8489323f, 0f, float.NaN), 32, false);
+            TestUtils.AreEqual(exp10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_float4()
+        {
+            TestUtils.AreEqual(exp10(float4(-10f, -1.2f, 0f, 1.2f)), float4(1E-10f, 0.06309573f, 1f, 15.8489323f), 32, false);
+            TestUtils.AreEqual(exp10(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(0f, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_double()
+        {
+            TestUtils.AreEqual(exp10(-10.0), 1E-10, 32, false);
+            TestUtils.AreEqual(exp10(-1.2), 0.063095734448019331, 32, false);
+            TestUtils.AreEqual(exp10(0.0), 1.0, 32, false);
+            TestUtils.AreEqual(exp10(1.2), 15.848931924611135, 32, false);
+            TestUtils.AreEqual(exp10(double.NegativeInfinity), 0.0, 32, false);
+            TestUtils.AreEqual(exp10(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(exp10(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_double2()
+        {
+            TestUtils.AreEqual(exp10(double2(-10.0, -1.2)), double2(1E-10, 0.063095734448019331), 32, false);
+            TestUtils.AreEqual(exp10(double2(0.0, 1.2)), double2(1.0, 15.848931924611135), 32, false);
+            TestUtils.AreEqual(exp10(double2(double.NegativeInfinity, double.NaN)), double2(0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp10(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_double3()
+        {
+            TestUtils.AreEqual(exp10(double3(-10.0, -1.2, 0.0)), double3(1E-10, 0.063095734448019331, 1.0), 32, false);
+            TestUtils.AreEqual(exp10(double3(1.2, double.NegativeInfinity, double.NaN)), double3(15.848931924611135, 0.0, double.NaN), 32, false);
+            TestUtils.AreEqual(exp10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void exp10_double4()
+        {
+            TestUtils.AreEqual(exp10(double4(-10.0, -1.2, 0.0, 1.2)), double4(1E-10, 0.063095734448019331, 1.0, 15.848931924611135), 32, false);
+            TestUtils.AreEqual(exp10(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(0.0, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log_float()
+        {
+            TestUtils.AreEqual(log(1.2E-09f), -20.5409451f, 1, false);
+            TestUtils.AreEqual(log(1f), 0f, 1, false);
+            TestUtils.AreEqual(log(1.2E+10f), 23.2081718f, 1, false);
+            TestUtils.AreEqual(log(-1f), float.NaN, 1, false);
+            TestUtils.AreEqual(log(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(log(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(log(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void log_float2()
+        {
+            TestUtils.AreEqual(log(float2(1.2E-09f, 1f)), float2(-20.5409451f, 0f), 1, false);
+            TestUtils.AreEqual(log(float2(1.2E+10f, -1f)), float2(23.2081718f, float.NaN), 1, false);
+            TestUtils.AreEqual(log(float2(float.NegativeInfinity, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log_float3()
+        {
+            TestUtils.AreEqual(log(float3(1.2E-09f, 1f, 1.2E+10f)), float3(-20.5409451f, 0f, 23.2081718f), 1, false);
+            TestUtils.AreEqual(log(float3(-1f, float.NegativeInfinity, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log_float4()
+        {
+            TestUtils.AreEqual(log(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), float4(-20.5409451f, 0f, 23.2081718f, float.NaN), 1, false);
+            TestUtils.AreEqual(log(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log_double()
+        {
+            TestUtils.AreEqual(log(1.2E-09), -20.540944280152456, 32, false);
+            TestUtils.AreEqual(log(1.0), 0.0, 32, false);
+            TestUtils.AreEqual(log(12000000000.0), 23.208172486734409, 32, false);
+            TestUtils.AreEqual(log(-1.0), double.NaN, 32, false);
+            TestUtils.AreEqual(log(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(log(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(log(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void log_double2()
+        {
+            TestUtils.AreEqual(log(double2(1.2E-09, 1.0)), double2(-20.540944280152456, 0.0), 32, false);
+            TestUtils.AreEqual(log(double2(12000000000.0, -1.0)), double2(23.208172486734409, double.NaN), 32, false);
+            TestUtils.AreEqual(log(double2(double.NegativeInfinity, double.NaN)), double2(double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log_double3()
+        {
+            TestUtils.AreEqual(log(double3(1.2E-09, 1.0, 12000000000.0)), double3(-20.540944280152456, 0.0, 23.208172486734409), 32, false);
+            TestUtils.AreEqual(log(double3(-1.0, double.NegativeInfinity, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log_double4()
+        {
+            TestUtils.AreEqual(log(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), double4(-20.540944280152456, 0.0, 23.208172486734409, double.NaN), 32, false);
+            TestUtils.AreEqual(log(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log2_float()
+        {
+            TestUtils.AreEqual(log2(1.2E-09f), -29.63432f, 1, false);
+            TestUtils.AreEqual(log2(1f), 0f, 1, false);
+            TestUtils.AreEqual(log2(1.2E+10f), 33.4823151f, 1, false);
+            TestUtils.AreEqual(log2(-1f), float.NaN, 1, false);
+            TestUtils.AreEqual(log2(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(log2(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(log2(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void log2_float2()
+        {
+            TestUtils.AreEqual(log2(float2(1.2E-09f, 1f)), float2(-29.63432f, 0f), 1, false);
+            TestUtils.AreEqual(log2(float2(1.2E+10f, -1f)), float2(33.4823151f, float.NaN), 1, false);
+            TestUtils.AreEqual(log2(float2(float.NegativeInfinity, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log2(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log2_float3()
+        {
+            TestUtils.AreEqual(log2(float3(1.2E-09f, 1f, 1.2E+10f)), float3(-29.63432f, 0f, 33.4823151f), 1, false);
+            TestUtils.AreEqual(log2(float3(-1f, float.NegativeInfinity, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log2_float4()
+        {
+            TestUtils.AreEqual(log2(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), float4(-29.63432f, 0f, 33.4823151f, float.NaN), 1, false);
+            TestUtils.AreEqual(log2(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log2_double()
+        {
+            TestUtils.AreEqual(log2(1.2E-09), -29.634318448152467, 32, false);
+            TestUtils.AreEqual(log2(1.0), 0.0, 32, false);
+            TestUtils.AreEqual(log2(12000000000.0), 33.482315354707417, 32, false);
+            TestUtils.AreEqual(log2(-1.0), double.NaN, 32, false);
+            TestUtils.AreEqual(log2(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(log2(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(log2(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void log2_double2()
+        {
+            TestUtils.AreEqual(log2(double2(1.2E-09, 1.0)), double2(-29.634318448152467, 0.0), 32, false);
+            TestUtils.AreEqual(log2(double2(12000000000.0, -1.0)), double2(33.482315354707417, double.NaN), 32, false);
+            TestUtils.AreEqual(log2(double2(double.NegativeInfinity, double.NaN)), double2(double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log2(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log2_double3()
+        {
+            TestUtils.AreEqual(log2(double3(1.2E-09, 1.0, 12000000000.0)), double3(-29.634318448152467, 0.0, 33.482315354707417), 32, false);
+            TestUtils.AreEqual(log2(double3(-1.0, double.NegativeInfinity, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log2_double4()
+        {
+            TestUtils.AreEqual(log2(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), double4(-29.634318448152467, 0.0, 33.482315354707417, double.NaN), 32, false);
+            TestUtils.AreEqual(log2(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log10_float()
+        {
+            TestUtils.AreEqual(log10(1.2E-09f), -8.920818f, 1, false);
+            TestUtils.AreEqual(log10(1f), 0f, 1, false);
+            TestUtils.AreEqual(log10(1.2E+10f), 10.0791817f, 1, false);
+            TestUtils.AreEqual(log10(-1f), float.NaN, 1, false);
+            TestUtils.AreEqual(log10(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(log10(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(log10(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void log10_float2()
+        {
+            TestUtils.AreEqual(log10(float2(1.2E-09f, 1f)), float2(-8.920818f, 0f), 1, false);
+            TestUtils.AreEqual(log10(float2(1.2E+10f, -1f)), float2(10.0791817f, float.NaN), 1, false);
+            TestUtils.AreEqual(log10(float2(float.NegativeInfinity, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log10(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log10_float3()
+        {
+            TestUtils.AreEqual(log10(float3(1.2E-09f, 1f, 1.2E+10f)), float3(-8.920818f, 0f, 10.0791817f), 1, false);
+            TestUtils.AreEqual(log10(float3(-1f, float.NegativeInfinity, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(log10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log10_float4()
+        {
+            TestUtils.AreEqual(log10(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), float4(-8.920818f, 0f, 10.0791817f, float.NaN), 1, false);
+            TestUtils.AreEqual(log10(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void log10_double()
+        {
+            TestUtils.AreEqual(log10(1.2E-09), -8.9208187539523749, 32, false);
+            TestUtils.AreEqual(log10(1.0), 0.0, 32, false);
+            TestUtils.AreEqual(log10(12000000000.0), 10.079181246047623, 32, false);
+            TestUtils.AreEqual(log10(-1.0), double.NaN, 32, false);
+            TestUtils.AreEqual(log10(double.NegativeInfinity), double.NaN, 32, false);
+            TestUtils.AreEqual(log10(double.NaN), double.NaN, 32, false);
+            TestUtils.AreEqual(log10(double.PositiveInfinity), double.PositiveInfinity, 32, false);
+        }
+
+        [TestCompiler]
+        public static void log10_double2()
+        {
+            TestUtils.AreEqual(log10(double2(1.2E-09, 1.0)), double2(-8.9208187539523749, 0.0), 32, false);
+            TestUtils.AreEqual(log10(double2(12000000000.0, -1.0)), double2(10.079181246047623, double.NaN), 32, false);
+            TestUtils.AreEqual(log10(double2(double.NegativeInfinity, double.NaN)), double2(double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log10(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log10_double3()
+        {
+            TestUtils.AreEqual(log10(double3(1.2E-09, 1.0, 12000000000.0)), double3(-8.9208187539523749, 0.0, 10.079181246047623), 32, false);
+            TestUtils.AreEqual(log10(double3(-1.0, double.NegativeInfinity, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 32, false);
+            TestUtils.AreEqual(log10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void log10_double4()
+        {
+            TestUtils.AreEqual(log10(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), double4(-8.9208187539523749, 0.0, 10.079181246047623, double.NaN), 32, false);
+            TestUtils.AreEqual(log10(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 32, false);
+        }
+
+        [TestCompiler]
+        public static void radians_float()
+        {
+            TestUtils.AreEqual(radians(-123.45f), -2.154609f, 1, false);
+            TestUtils.AreEqual(radians(0f), 0f, 1, false);
+            TestUtils.AreEqual(radians(123.45f), 2.154609f, 1, false);
+            TestUtils.AreEqual(radians(float.NegativeInfinity), float.NegativeInfinity, 1, false);
+            TestUtils.AreEqual(radians(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(radians(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_float2()
+        {
+            TestUtils.AreEqual(radians(float2(-123.45f, 0f)), float2(-2.154609f, 0f), 1, false);
+            TestUtils.AreEqual(radians(float2(123.45f, float.NegativeInfinity)), float2(2.154609f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(radians(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_float3()
+        {
+            TestUtils.AreEqual(radians(float3(-123.45f, 0f, 123.45f)), float3(-2.154609f, 0f, 2.154609f), 1, false);
+            TestUtils.AreEqual(radians(float3(float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float3(float.NegativeInfinity, float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_float4()
+        {
+            TestUtils.AreEqual(radians(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), float4(-2.154609f, 0f, 2.154609f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(radians(float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_double()
+        {
+            TestUtils.AreEqual(radians(-123.45), -2.154608961587, 1, false);
+            TestUtils.AreEqual(radians(0.0), 0.0, 1, false);
+            TestUtils.AreEqual(radians(123.45), 2.154608961587, 1, false);
+            TestUtils.AreEqual(radians(double.NegativeInfinity), double.NegativeInfinity, 1, false);
+            TestUtils.AreEqual(radians(double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(radians(double.PositiveInfinity), double.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_double2()
+        {
+            TestUtils.AreEqual(radians(double2(-123.45, 0.0)), double2(-2.154608961587, 0.0), 1, false);
+            TestUtils.AreEqual(radians(double2(123.45, double.NegativeInfinity)), double2(2.154608961587, double.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(radians(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_double3()
+        {
+            TestUtils.AreEqual(radians(double3(-123.45, 0.0, 123.45)), double3(-2.154608961587, 0.0, 2.154608961587), 1, false);
+            TestUtils.AreEqual(radians(double3(double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double3(double.NegativeInfinity, double.NaN, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void radians_double4()
+        {
+            TestUtils.AreEqual(radians(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), double4(-2.154608961587, 0.0, 2.154608961587, double.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(radians(double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_float()
+        {
+            TestUtils.AreEqual(degrees(-123.45f), -7073.164f, 1, false);
+            TestUtils.AreEqual(degrees(0f), 0f, 1, false);
+            TestUtils.AreEqual(degrees(123.45f), 7073.164f, 1, false);
+            TestUtils.AreEqual(degrees(float.NegativeInfinity), float.NegativeInfinity, 1, false);
+            TestUtils.AreEqual(degrees(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(degrees(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_float2()
+        {
+            TestUtils.AreEqual(degrees(float2(-123.45f, 0f)), float2(-7073.164f, 0f), 1, false);
+            TestUtils.AreEqual(degrees(float2(123.45f, float.NegativeInfinity)), float2(7073.164f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(degrees(float2(float.NaN, float.PositiveInfinity)), float2(float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_float3()
+        {
+            TestUtils.AreEqual(degrees(float3(-123.45f, 0f, 123.45f)), float3(-7073.164f, 0f, 7073.164f), 1, false);
+            TestUtils.AreEqual(degrees(float3(float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float3(float.NegativeInfinity, float.NaN, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_float4()
+        {
+            TestUtils.AreEqual(degrees(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), float4(-7073.164f, 0f, 7073.164f, float.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(degrees(float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_double()
+        {
+            TestUtils.AreEqual(degrees(-123.45), -7073.1639808900127, 1, false);
+            TestUtils.AreEqual(degrees(0.0), 0.0, 1, false);
+            TestUtils.AreEqual(degrees(123.45), 7073.1639808900127, 1, false);
+            TestUtils.AreEqual(degrees(double.NegativeInfinity), double.NegativeInfinity, 1, false);
+            TestUtils.AreEqual(degrees(double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(degrees(double.PositiveInfinity), double.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_double2()
+        {
+            TestUtils.AreEqual(degrees(double2(-123.45, 0.0)), double2(-7073.1639808900127, 0.0), 1, false);
+            TestUtils.AreEqual(degrees(double2(123.45, double.NegativeInfinity)), double2(7073.1639808900127, double.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(degrees(double2(double.NaN, double.PositiveInfinity)), double2(double.NaN, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_double3()
+        {
+            TestUtils.AreEqual(degrees(double3(-123.45, 0.0, 123.45)), double3(-7073.1639808900127, 0.0, 7073.1639808900127), 1, false);
+            TestUtils.AreEqual(degrees(double3(double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double3(double.NegativeInfinity, double.NaN, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void degrees_double4()
+        {
+            TestUtils.AreEqual(degrees(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), double4(-7073.1639808900127, 0.0, 7073.1639808900127, double.NegativeInfinity), 1, false);
+            TestUtils.AreEqual(degrees(double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sign_float()
+        {
+            TestUtils.AreEqual(sign(-123.45f), -1f);
+            TestUtils.AreEqual(sign(-1E-20f), -1f);
+            TestUtils.AreEqual(sign(0f), 0f);
+            TestUtils.AreEqual(sign(1E-10f), 1f);
+            TestUtils.AreEqual(sign(123.45f), 1f);
+            TestUtils.AreEqual(sign(float.NegativeInfinity), -1f);
+            TestUtils.AreEqual(sign(float.NaN), 0f);
+            TestUtils.AreEqual(sign(float.PositiveInfinity), 1f);
+        }
+
+        [TestCompiler]
+        public static void sign_float2()
+        {
+            TestUtils.AreEqual(sign(float2(-123.45f, -1E-20f)), float2(-1f, -1f));
+            TestUtils.AreEqual(sign(float2(0f, 1E-10f)), float2(0f, 1f));
+            TestUtils.AreEqual(sign(float2(123.45f, float.NegativeInfinity)), float2(1f, -1f));
+            TestUtils.AreEqual(sign(float2(float.NaN, float.PositiveInfinity)), float2(0f, 1f));
+        }
+
+        [TestCompiler]
+        public static void sign_float3()
+        {
+            TestUtils.AreEqual(sign(float3(-123.45f, -1E-20f, 0f)), float3(-1f, -1f, 0f));
+            TestUtils.AreEqual(sign(float3(1E-10f, 123.45f, float.NegativeInfinity)), float3(1f, 1f, -1f));
+            TestUtils.AreEqual(sign(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(0f, 1f, 1f));
+        }
+
+        [TestCompiler]
+        public static void sign_float4()
+        {
+            TestUtils.AreEqual(sign(float4(-123.45f, -1E-20f, 0f, 1E-10f)), float4(-1f, -1f, 0f, 1f));
+            TestUtils.AreEqual(sign(float4(123.45f, float.NegativeInfinity, float.NaN, float.PositiveInfinity)), float4(1f, -1f, 0f, 1f));
+        }
+
+        [TestCompiler]
+        public static void sign_double()
+        {
+            TestUtils.AreEqual(sign(-123.45), -1.0);
+            TestUtils.AreEqual(sign(-1E-20), -1.0);
+            TestUtils.AreEqual(sign(0.0), 0.0);
+            TestUtils.AreEqual(sign(1E-10), 1.0);
+            TestUtils.AreEqual(sign(123.45), 1.0);
+            TestUtils.AreEqual(sign(double.NegativeInfinity), -1.0);
+            TestUtils.AreEqual(sign(double.NaN), 0.0);
+            TestUtils.AreEqual(sign(double.PositiveInfinity), 1.0);
+        }
+
+        [TestCompiler]
+        public static void sign_double2()
+        {
+            TestUtils.AreEqual(sign(double2(-123.45, -1E-20)), double2(-1.0, -1.0));
+            TestUtils.AreEqual(sign(double2(0.0, 1E-10)), double2(0.0, 1.0));
+            TestUtils.AreEqual(sign(double2(123.45, double.NegativeInfinity)), double2(1.0, -1.0));
+            TestUtils.AreEqual(sign(double2(double.NaN, double.PositiveInfinity)), double2(0.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void sign_double3()
+        {
+            TestUtils.AreEqual(sign(double3(-123.45, -1E-20, 0.0)), double3(-1.0, -1.0, 0.0));
+            TestUtils.AreEqual(sign(double3(1E-10, 123.45, double.NegativeInfinity)), double3(1.0, 1.0, -1.0));
+            TestUtils.AreEqual(sign(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(0.0, 1.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void sign_double4()
+        {
+            TestUtils.AreEqual(sign(double4(-123.45, -1E-20, 0.0, 1E-10)), double4(-1.0, -1.0, 0.0, 1.0));
+            TestUtils.AreEqual(sign(double4(123.45, double.NegativeInfinity, double.NaN, double.PositiveInfinity)), double4(1.0, -1.0, 0.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void sqrt_float()
+        {
+            TestUtils.AreEqual(sqrt(-1f), float.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(0f), 0f, 1, false);
+            TestUtils.AreEqual(sqrt(1E-10f), 1E-05f, 1, false);
+            TestUtils.AreEqual(sqrt(123.45f), 11.1108055f, 1, false);
+            TestUtils.AreEqual(sqrt(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(float.PositiveInfinity), float.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_float2()
+        {
+            TestUtils.AreEqual(sqrt(float2(-1f, 0f)), float2(float.NaN, 0f), 1, false);
+            TestUtils.AreEqual(sqrt(float2(1E-10f, 123.45f)), float2(1E-05f, 11.1108055f), 1, false);
+            TestUtils.AreEqual(sqrt(float2(float.NegativeInfinity, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(sqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_float3()
+        {
+            TestUtils.AreEqual(sqrt(float3(-1f, 0f, 1E-10f)), float3(float.NaN, 0f, 1E-05f), 1, false);
+            TestUtils.AreEqual(sqrt(float3(123.45f, float.NegativeInfinity, float.NaN)), float3(11.1108055f, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(sqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_float4()
+        {
+            TestUtils.AreEqual(sqrt(float4(-1f, 0f, 1E-10f, 123.45f)), float4(float.NaN, 0f, 1E-05f, 11.1108055f), 1, false);
+            TestUtils.AreEqual(sqrt(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.NaN, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_double()
+        {
+            TestUtils.AreEqual(sqrt(-1.0), double.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(0.0), 0.0, 1, false);
+            TestUtils.AreEqual(sqrt(1E-10), 1E-05, 1, false);
+            TestUtils.AreEqual(sqrt(123.45), 11.11080555135405, 1, false);
+            TestUtils.AreEqual(sqrt(double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(sqrt(double.PositiveInfinity), double.PositiveInfinity, 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_double2()
+        {
+            TestUtils.AreEqual(sqrt(double2(-1.0, 0.0)), double2(double.NaN, 0.0), 1, false);
+            TestUtils.AreEqual(sqrt(double2(1E-10, 123.45)), double2(1E-05, 11.11080555135405), 1, false);
+            TestUtils.AreEqual(sqrt(double2(double.NegativeInfinity, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(sqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_double3()
+        {
+            TestUtils.AreEqual(sqrt(double3(-1.0, 0.0, 1E-10)), double3(double.NaN, 0.0, 1E-05), 1, false);
+            TestUtils.AreEqual(sqrt(double3(123.45, double.NegativeInfinity, double.NaN)), double3(11.11080555135405, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(sqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void sqrt_double4()
+        {
+            TestUtils.AreEqual(sqrt(double4(-1.0, 0.0, 1E-10, 123.45)), double4(double.NaN, 0.0, 1E-05, 11.11080555135405), 1, false);
+            TestUtils.AreEqual(sqrt(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.NaN, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_float()
+        {
+            TestUtils.AreEqual(rsqrt(-1f), float.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(0f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(rsqrt(1E+10f), 1E-05f, 1, false);
+            TestUtils.AreEqual(rsqrt(123.45f), 0.09000248f, 1, false);
+            TestUtils.AreEqual(rsqrt(float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(float.PositiveInfinity), 0f, 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_float2()
+        {
+            TestUtils.AreEqual(rsqrt(float2(-1f, 0f)), float2(float.NaN, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(rsqrt(float2(1E+10f, 123.45f)), float2(1E-05f, 0.09000248f), 1, false);
+            TestUtils.AreEqual(rsqrt(float2(float.NegativeInfinity, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(rsqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_float3()
+        {
+            TestUtils.AreEqual(rsqrt(float3(-1f, 0f, 1E+10f)), float3(float.NaN, float.PositiveInfinity, 1E-05f), 1, false);
+            TestUtils.AreEqual(rsqrt(float3(123.45f, float.NegativeInfinity, float.NaN)), float3(0.09000248f, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(rsqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(0f, 0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_float4()
+        {
+            TestUtils.AreEqual(rsqrt(float4(-1f, 0f, 1E+10f, 123.45f)), float4(float.NaN, float.PositiveInfinity, 1E-05f, 0.09000248f), 1, false);
+            TestUtils.AreEqual(rsqrt(float4(float.NegativeInfinity, float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.NaN, 0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_double()
+        {
+            TestUtils.AreEqual(rsqrt(-1.0), double.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(0.0), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(rsqrt(10000000000.0), 1E-05, 1, false);
+            TestUtils.AreEqual(rsqrt(123.45), 0.090002475102098425, 1, false);
+            TestUtils.AreEqual(rsqrt(double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(rsqrt(double.PositiveInfinity), 0.0, 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_double2()
+        {
+            TestUtils.AreEqual(rsqrt(double2(-1.0, 0.0)), double2(double.NaN, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(rsqrt(double2(10000000000.0, 123.45)), double2(1E-05, 0.090002475102098425), 1, false);
+            TestUtils.AreEqual(rsqrt(double2(double.NegativeInfinity, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(rsqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_double3()
+        {
+            TestUtils.AreEqual(rsqrt(double3(-1.0, 0.0, 10000000000.0)), double3(double.NaN, double.PositiveInfinity, 1E-05), 1, false);
+            TestUtils.AreEqual(rsqrt(double3(123.45, double.NegativeInfinity, double.NaN)), double3(0.090002475102098425, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(rsqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(0.0, 0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rsqrt_double4()
+        {
+            TestUtils.AreEqual(rsqrt(double4(-1.0, 0.0, 10000000000.0, 123.45)), double4(double.NaN, double.PositiveInfinity, 1E-05, 0.090002475102098425), 1, false);
+            TestUtils.AreEqual(rsqrt(double4(double.NegativeInfinity, double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.NaN, 0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_float()
+        {
+            TestUtils.AreEqual(rcp(-123.45f), -0.008100445f, 1, false);
+            TestUtils.AreEqual(rcp(0f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(rcp(123.45f), 0.008100445f, 1, false);
+            TestUtils.AreEqual(rcp(float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(rcp(float.PositiveInfinity), 0f, 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_float2()
+        {
+            TestUtils.AreEqual(rcp(float2(-123.45f, 0f)), float2(-0.008100445f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(rcp(float2(123.45f, float.NaN)), float2(0.008100445f, float.NaN), 1, false);
+            TestUtils.AreEqual(rcp(float2(float.PositiveInfinity, float.PositiveInfinity)), float2(0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_float3()
+        {
+            TestUtils.AreEqual(rcp(float3(-123.45f, 0f, 123.45f)), float3(-0.008100445f, float.PositiveInfinity, 0.008100445f), 1, false);
+            TestUtils.AreEqual(rcp(float3(float.NaN, float.PositiveInfinity, float.PositiveInfinity)), float3(float.NaN, 0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_float4()
+        {
+            TestUtils.AreEqual(rcp(float4(-123.45f, 0f, 123.45f, float.NaN)), float4(-0.008100445f, float.PositiveInfinity, 0.008100445f, float.NaN), 1, false);
+            TestUtils.AreEqual(rcp(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(0f, 0f, 0f, 0f), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_double()
+        {
+            TestUtils.AreEqual(rcp(-123.45), -0.0081004455245038479, 1, false);
+            TestUtils.AreEqual(rcp(0.0), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(rcp(123.45), 0.0081004455245038479, 1, false);
+            TestUtils.AreEqual(rcp(double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(rcp(double.PositiveInfinity), 0.0, 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_double2()
+        {
+            TestUtils.AreEqual(rcp(double2(-123.45, 0.0)), double2(-0.0081004455245038479, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(rcp(double2(123.45, double.NaN)), double2(0.0081004455245038479, double.NaN), 1, false);
+            TestUtils.AreEqual(rcp(double2(double.PositiveInfinity, double.PositiveInfinity)), double2(0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_double3()
+        {
+            TestUtils.AreEqual(rcp(double3(-123.45, 0.0, 123.45)), double3(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479), 1, false);
+            TestUtils.AreEqual(rcp(double3(double.NaN, double.PositiveInfinity, double.PositiveInfinity)), double3(double.NaN, 0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void rcp_double4()
+        {
+            TestUtils.AreEqual(rcp(double4(-123.45, 0.0, 123.45, double.NaN)), double4(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479, double.NaN), 1, false);
+            TestUtils.AreEqual(rcp(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(0.0, 0.0, 0.0, 0.0), 1, false);
+        }
+
+        [TestCompiler]
+        public static void floor_float()
+        {
+            TestUtils.AreEqual(floor(float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(floor(-100.51f), -101f);
+            TestUtils.AreEqual(floor(-100.5f), -101f);
+            TestUtils.AreEqual(floor(-100.49f), -101f);
+            TestUtils.AreEqual(floor(0f), 0f);
+            TestUtils.AreEqual(floor(100.49f), 100f);
+            TestUtils.AreEqual(floor(100.5f), 100f);
+            TestUtils.AreEqual(floor(100.51f), 100f);
+            TestUtils.AreEqual(floor(float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(floor(float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void floor_float2()
+        {
+            TestUtils.AreEqual(floor(float2(float.NegativeInfinity, -100.51f)), float2(float.NegativeInfinity, -101f));
+            TestUtils.AreEqual(floor(float2(-100.5f, -100.49f)), float2(-101f, -101f));
+            TestUtils.AreEqual(floor(float2(0f, 100.49f)), float2(0f, 100f));
+            TestUtils.AreEqual(floor(float2(100.5f, 100.51f)), float2(100f, 100f));
+            TestUtils.AreEqual(floor(float2(float.PositiveInfinity, float.NaN)), float2(float.PositiveInfinity, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void floor_float3()
+        {
+            TestUtils.AreEqual(floor(float3(float.NegativeInfinity, -100.51f, -100.5f)), float3(float.NegativeInfinity, -101f, -101f));
+            TestUtils.AreEqual(floor(float3(-100.49f, 0f, 100.49f)), float3(-101f, 0f, 100f));
+            TestUtils.AreEqual(floor(float3(100.5f, 100.51f, float.PositiveInfinity)), float3(100f, 100f, float.PositiveInfinity));
+            TestUtils.AreEqual(floor(float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void floor_float4()
+        {
+            TestUtils.AreEqual(floor(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)), float4(float.NegativeInfinity, -101f, -101f, -101f));
+            TestUtils.AreEqual(floor(float4(0f, 100.49f, 100.5f, 100.51f)), float4(0f, 100f, 100f, 100f));
+            TestUtils.AreEqual(floor(float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN)), float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void floor_double()
+        {
+            TestUtils.AreEqual(floor(double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(floor(-100.51), -101.0);
+            TestUtils.AreEqual(floor(-100.5), -101.0);
+            TestUtils.AreEqual(floor(-100.49), -101.0);
+            TestUtils.AreEqual(floor(0.0), 0.0);
+            TestUtils.AreEqual(floor(100.49), 100.0);
+            TestUtils.AreEqual(floor(100.5), 100.0);
+            TestUtils.AreEqual(floor(100.51), 100.0);
+            TestUtils.AreEqual(floor(double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(floor(double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void floor_double2()
+        {
+            TestUtils.AreEqual(floor(double2(double.NegativeInfinity, -100.51)), double2(double.NegativeInfinity, -101.0));
+            TestUtils.AreEqual(floor(double2(-100.5, -100.49)), double2(-101.0, -101.0));
+            TestUtils.AreEqual(floor(double2(0.0, 100.49)), double2(0.0, 100.0));
+            TestUtils.AreEqual(floor(double2(100.5, 100.51)), double2(100.0, 100.0));
+            TestUtils.AreEqual(floor(double2(double.PositiveInfinity, double.NaN)), double2(double.PositiveInfinity, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void floor_double3()
+        {
+            TestUtils.AreEqual(floor(double3(double.NegativeInfinity, -100.51, -100.5)), double3(double.NegativeInfinity, -101.0, -101.0));
+            TestUtils.AreEqual(floor(double3(-100.49, 0.0, 100.49)), double3(-101.0, 0.0, 100.0));
+            TestUtils.AreEqual(floor(double3(100.5, 100.51, double.PositiveInfinity)), double3(100.0, 100.0, double.PositiveInfinity));
+            TestUtils.AreEqual(floor(double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void floor_double4()
+        {
+            TestUtils.AreEqual(floor(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)), double4(double.NegativeInfinity, -101.0, -101.0, -101.0));
+            TestUtils.AreEqual(floor(double4(0.0, 100.49, 100.5, 100.51)), double4(0.0, 100.0, 100.0, 100.0));
+            TestUtils.AreEqual(floor(double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN)), double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_float()
+        {
+            TestUtils.AreEqual(ceil(float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(ceil(-100.51f), -100f);
+            TestUtils.AreEqual(ceil(-100.5f), -100f);
+            TestUtils.AreEqual(ceil(-100.49f), -100f);
+            TestUtils.AreEqual(ceil(0f), 0f);
+            TestUtils.AreEqual(ceil(100.49f), 101f);
+            TestUtils.AreEqual(ceil(100.5f), 101f);
+            TestUtils.AreEqual(ceil(100.51f), 101f);
+            TestUtils.AreEqual(ceil(float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(ceil(float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void ceil_float2()
+        {
+            TestUtils.AreEqual(ceil(float2(float.NegativeInfinity, -100.51f)), float2(float.NegativeInfinity, -100f));
+            TestUtils.AreEqual(ceil(float2(-100.5f, -100.49f)), float2(-100f, -100f));
+            TestUtils.AreEqual(ceil(float2(0f, 100.49f)), float2(0f, 101f));
+            TestUtils.AreEqual(ceil(float2(100.5f, 100.51f)), float2(101f, 101f));
+            TestUtils.AreEqual(ceil(float2(float.PositiveInfinity, float.NaN)), float2(float.PositiveInfinity, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_float3()
+        {
+            TestUtils.AreEqual(ceil(float3(float.NegativeInfinity, -100.51f, -100.5f)), float3(float.NegativeInfinity, -100f, -100f));
+            TestUtils.AreEqual(ceil(float3(-100.49f, 0f, 100.49f)), float3(-100f, 0f, 101f));
+            TestUtils.AreEqual(ceil(float3(100.5f, 100.51f, float.PositiveInfinity)), float3(101f, 101f, float.PositiveInfinity));
+            TestUtils.AreEqual(ceil(float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_float4()
+        {
+            TestUtils.AreEqual(ceil(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)), float4(float.NegativeInfinity, -100f, -100f, -100f));
+            TestUtils.AreEqual(ceil(float4(0f, 100.49f, 100.5f, 100.51f)), float4(0f, 101f, 101f, 101f));
+            TestUtils.AreEqual(ceil(float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN)), float4(float.PositiveInfinity, float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_double()
+        {
+            TestUtils.AreEqual(ceil(double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(ceil(-100.51), -100.0);
+            TestUtils.AreEqual(ceil(-100.5), -100.0);
+            TestUtils.AreEqual(ceil(-100.49), -100.0);
+            TestUtils.AreEqual(ceil(0.0), 0.0);
+            TestUtils.AreEqual(ceil(100.49), 101.0);
+            TestUtils.AreEqual(ceil(100.5), 101.0);
+            TestUtils.AreEqual(ceil(100.51), 101.0);
+            TestUtils.AreEqual(ceil(double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(ceil(double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void ceil_double2()
+        {
+            TestUtils.AreEqual(ceil(double2(double.NegativeInfinity, -100.51)), double2(double.NegativeInfinity, -100.0));
+            TestUtils.AreEqual(ceil(double2(-100.5, -100.49)), double2(-100.0, -100.0));
+            TestUtils.AreEqual(ceil(double2(0.0, 100.49)), double2(0.0, 101.0));
+            TestUtils.AreEqual(ceil(double2(100.5, 100.51)), double2(101.0, 101.0));
+            TestUtils.AreEqual(ceil(double2(double.PositiveInfinity, double.NaN)), double2(double.PositiveInfinity, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_double3()
+        {
+            TestUtils.AreEqual(ceil(double3(double.NegativeInfinity, -100.51, -100.5)), double3(double.NegativeInfinity, -100.0, -100.0));
+            TestUtils.AreEqual(ceil(double3(-100.49, 0.0, 100.49)), double3(-100.0, 0.0, 101.0));
+            TestUtils.AreEqual(ceil(double3(100.5, 100.51, double.PositiveInfinity)), double3(101.0, 101.0, double.PositiveInfinity));
+            TestUtils.AreEqual(ceil(double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void ceil_double4()
+        {
+            TestUtils.AreEqual(ceil(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)), double4(double.NegativeInfinity, -100.0, -100.0, -100.0));
+            TestUtils.AreEqual(ceil(double4(0.0, 100.49, 100.5, 100.51)), double4(0.0, 101.0, 101.0, 101.0));
+            TestUtils.AreEqual(ceil(double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN)), double4(double.PositiveInfinity, double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_float()
+        {
+            TestUtils.AreEqual(round(float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(round(-100.51f), -101f);
+            TestUtils.AreEqual(round(-100.5f), -100f);
+            TestUtils.AreEqual(round(-100.49f), -100f);
+            TestUtils.AreEqual(round(0f), 0f);
+            TestUtils.AreEqual(round(100.49f), 100f);
+            TestUtils.AreEqual(round(100.5f), 100f);
+            TestUtils.AreEqual(round(100.51f), 101f);
+            TestUtils.AreEqual(round(101.5f), 102f);
+            TestUtils.AreEqual(round(float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(round(float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void round_float2()
+        {
+            TestUtils.AreEqual(round(float2(float.NegativeInfinity, -100.51f)), float2(float.NegativeInfinity, -101f));
+            TestUtils.AreEqual(round(float2(-100.5f, -100.49f)), float2(-100f, -100f));
+            TestUtils.AreEqual(round(float2(0f, 100.49f)), float2(0f, 100f));
+            TestUtils.AreEqual(round(float2(100.5f, 100.51f)), float2(100f, 101f));
+            TestUtils.AreEqual(round(float2(101.5f, float.PositiveInfinity)), float2(102f, float.PositiveInfinity));
+            TestUtils.AreEqual(round(float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_float3()
+        {
+            TestUtils.AreEqual(round(float3(float.NegativeInfinity, -100.51f, -100.5f)), float3(float.NegativeInfinity, -101f, -100f));
+            TestUtils.AreEqual(round(float3(-100.49f, 0f, 100.49f)), float3(-100f, 0f, 100f));
+            TestUtils.AreEqual(round(float3(100.5f, 100.51f, 101.5f)), float3(100f, 101f, 102f));
+            TestUtils.AreEqual(round(float3(float.PositiveInfinity, float.NaN, float.NaN)), float3(float.PositiveInfinity, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_float4()
+        {
+            TestUtils.AreEqual(round(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)), float4(float.NegativeInfinity, -101f, -100f, -100f));
+            TestUtils.AreEqual(round(float4(0f, 100.49f, 100.5f, 100.51f)), float4(0f, 100f, 100f, 101f));
+            TestUtils.AreEqual(round(float4(101.5f, float.PositiveInfinity, float.NaN, float.NaN)), float4(102f, float.PositiveInfinity, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_double()
+        {
+            TestUtils.AreEqual(round(double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(round(-100.51), -101.0);
+            TestUtils.AreEqual(round(-100.5), -100.0);
+            TestUtils.AreEqual(round(-100.49), -100.0);
+            TestUtils.AreEqual(round(0.0), 0.0);
+            TestUtils.AreEqual(round(100.49), 100.0);
+            TestUtils.AreEqual(round(100.5), 100.0);
+            TestUtils.AreEqual(round(100.51), 101.0);
+            TestUtils.AreEqual(round(101.5), 102.0);
+            TestUtils.AreEqual(round(double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(round(double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void round_double2()
+        {
+            TestUtils.AreEqual(round(double2(double.NegativeInfinity, -100.51)), double2(double.NegativeInfinity, -101.0));
+            TestUtils.AreEqual(round(double2(-100.5, -100.49)), double2(-100.0, -100.0));
+            TestUtils.AreEqual(round(double2(0.0, 100.49)), double2(0.0, 100.0));
+            TestUtils.AreEqual(round(double2(100.5, 100.51)), double2(100.0, 101.0));
+            TestUtils.AreEqual(round(double2(101.5, double.PositiveInfinity)), double2(102.0, double.PositiveInfinity));
+            TestUtils.AreEqual(round(double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_double3()
+        {
+            TestUtils.AreEqual(round(double3(double.NegativeInfinity, -100.51, -100.5)), double3(double.NegativeInfinity, -101.0, -100.0));
+            TestUtils.AreEqual(round(double3(-100.49, 0.0, 100.49)), double3(-100.0, 0.0, 100.0));
+            TestUtils.AreEqual(round(double3(100.5, 100.51, 101.5)), double3(100.0, 101.0, 102.0));
+            TestUtils.AreEqual(round(double3(double.PositiveInfinity, double.NaN, double.NaN)), double3(double.PositiveInfinity, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void round_double4()
+        {
+            TestUtils.AreEqual(round(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)), double4(double.NegativeInfinity, -101.0, -100.0, -100.0));
+            TestUtils.AreEqual(round(double4(0.0, 100.49, 100.5, 100.51)), double4(0.0, 100.0, 100.0, 101.0));
+            TestUtils.AreEqual(round(double4(101.5, double.PositiveInfinity, double.NaN, double.NaN)), double4(102.0, double.PositiveInfinity, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_float()
+        {
+            TestUtils.AreEqual(trunc(float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(trunc(-100.51f), -100f);
+            TestUtils.AreEqual(trunc(-100.5f), -100f);
+            TestUtils.AreEqual(trunc(-100.49f), -100f);
+            TestUtils.AreEqual(trunc(0f), 0f);
+            TestUtils.AreEqual(trunc(100.49f), 100f);
+            TestUtils.AreEqual(trunc(100.5f), 100f);
+            TestUtils.AreEqual(trunc(100.51f), 100f);
+            TestUtils.AreEqual(trunc(101.5f), 101f);
+            TestUtils.AreEqual(trunc(float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(trunc(float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void trunc_float2()
+        {
+            TestUtils.AreEqual(trunc(float2(float.NegativeInfinity, -100.51f)), float2(float.NegativeInfinity, -100f));
+            TestUtils.AreEqual(trunc(float2(-100.5f, -100.49f)), float2(-100f, -100f));
+            TestUtils.AreEqual(trunc(float2(0f, 100.49f)), float2(0f, 100f));
+            TestUtils.AreEqual(trunc(float2(100.5f, 100.51f)), float2(100f, 100f));
+            TestUtils.AreEqual(trunc(float2(101.5f, float.PositiveInfinity)), float2(101f, float.PositiveInfinity));
+            TestUtils.AreEqual(trunc(float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_float3()
+        {
+            TestUtils.AreEqual(trunc(float3(float.NegativeInfinity, -100.51f, -100.5f)), float3(float.NegativeInfinity, -100f, -100f));
+            TestUtils.AreEqual(trunc(float3(-100.49f, 0f, 100.49f)), float3(-100f, 0f, 100f));
+            TestUtils.AreEqual(trunc(float3(100.5f, 100.51f, 101.5f)), float3(100f, 100f, 101f));
+            TestUtils.AreEqual(trunc(float3(float.PositiveInfinity, float.NaN, float.NaN)), float3(float.PositiveInfinity, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_float4()
+        {
+            TestUtils.AreEqual(trunc(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)), float4(float.NegativeInfinity, -100f, -100f, -100f));
+            TestUtils.AreEqual(trunc(float4(0f, 100.49f, 100.5f, 100.51f)), float4(0f, 100f, 100f, 100f));
+            TestUtils.AreEqual(trunc(float4(101.5f, float.PositiveInfinity, float.NaN, float.NaN)), float4(101f, float.PositiveInfinity, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_double()
+        {
+            TestUtils.AreEqual(trunc(double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(trunc(-100.51), -100.0);
+            TestUtils.AreEqual(trunc(-100.5), -100.0);
+            TestUtils.AreEqual(trunc(-100.49), -100.0);
+            TestUtils.AreEqual(trunc(0.0), 0.0);
+            TestUtils.AreEqual(trunc(100.49), 100.0);
+            TestUtils.AreEqual(trunc(100.5), 100.0);
+            TestUtils.AreEqual(trunc(100.51), 100.0);
+            TestUtils.AreEqual(trunc(101.5), 101.0);
+            TestUtils.AreEqual(trunc(double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(trunc(double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void trunc_double2()
+        {
+            TestUtils.AreEqual(trunc(double2(double.NegativeInfinity, -100.51)), double2(double.NegativeInfinity, -100.0));
+            TestUtils.AreEqual(trunc(double2(-100.5, -100.49)), double2(-100.0, -100.0));
+            TestUtils.AreEqual(trunc(double2(0.0, 100.49)), double2(0.0, 100.0));
+            TestUtils.AreEqual(trunc(double2(100.5, 100.51)), double2(100.0, 100.0));
+            TestUtils.AreEqual(trunc(double2(101.5, double.PositiveInfinity)), double2(101.0, double.PositiveInfinity));
+            TestUtils.AreEqual(trunc(double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_double3()
+        {
+            TestUtils.AreEqual(trunc(double3(double.NegativeInfinity, -100.51, -100.5)), double3(double.NegativeInfinity, -100.0, -100.0));
+            TestUtils.AreEqual(trunc(double3(-100.49, 0.0, 100.49)), double3(-100.0, 0.0, 100.0));
+            TestUtils.AreEqual(trunc(double3(100.5, 100.51, 101.5)), double3(100.0, 100.0, 101.0));
+            TestUtils.AreEqual(trunc(double3(double.PositiveInfinity, double.NaN, double.NaN)), double3(double.PositiveInfinity, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void trunc_double4()
+        {
+            TestUtils.AreEqual(trunc(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)), double4(double.NegativeInfinity, -100.0, -100.0, -100.0));
+            TestUtils.AreEqual(trunc(double4(0.0, 100.49, 100.5, 100.51)), double4(0.0, 100.0, 100.0, 100.0));
+            TestUtils.AreEqual(trunc(double4(101.5, double.PositiveInfinity, double.NaN, double.NaN)), double4(101.0, double.PositiveInfinity, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void frac_float()
+        {
+            TestUtils.AreEqual(frac(float.NegativeInfinity), float.NaN, 64, false);
+            TestUtils.AreEqual(frac(-1E+20f), 0f, 64, false);
+            TestUtils.AreEqual(frac(-100.3f), 0.7f, 64, false);
+            TestUtils.AreEqual(frac(0f), 0f, 64, false);
+            TestUtils.AreEqual(frac(100.8f), 0.8f, 64, false);
+            TestUtils.AreEqual(frac(float.PositiveInfinity), float.NaN, 64, false);
+            TestUtils.AreEqual(frac(float.NaN), float.NaN, 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_float2()
+        {
+            TestUtils.AreEqual(frac(float2(float.NegativeInfinity, -1E+20f)), float2(float.NaN, 0f), 64, false);
+            TestUtils.AreEqual(frac(float2(-100.3f, 0f)), float2(0.7f, 0f), 64, false);
+            TestUtils.AreEqual(frac(float2(100.8f, float.PositiveInfinity)), float2(0.8f, float.NaN), 64, false);
+            TestUtils.AreEqual(frac(float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_float3()
+        {
+            TestUtils.AreEqual(frac(float3(float.NegativeInfinity, -1E+20f, -100.3f)), float3(float.NaN, 0f, 0.7f), 64, false);
+            TestUtils.AreEqual(frac(float3(0f, 100.8f, float.PositiveInfinity)), float3(0f, 0.8f, float.NaN), 64, false);
+            TestUtils.AreEqual(frac(float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_float4()
+        {
+            TestUtils.AreEqual(frac(float4(float.NegativeInfinity, -1E+20f, -100.3f, 0f)), float4(float.NaN, 0f, 0.7f, 0f), 64, false);
+            TestUtils.AreEqual(frac(float4(100.8f, float.PositiveInfinity, float.NaN, float.NaN)), float4(0.8f, float.NaN, float.NaN, float.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_double()
+        {
+            TestUtils.AreEqual(frac(double.NegativeInfinity), double.NaN, 64, false);
+            TestUtils.AreEqual(frac(-1E+20), 0.0, 64, false);
+            TestUtils.AreEqual(frac(-100.3), 0.7, 64, false);
+            TestUtils.AreEqual(frac(0.0), 0.0, 64, false);
+            TestUtils.AreEqual(frac(100.8), 0.8, 64, false);
+            TestUtils.AreEqual(frac(double.PositiveInfinity), double.NaN, 64, false);
+            TestUtils.AreEqual(frac(double.NaN), double.NaN, 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_double2()
+        {
+            TestUtils.AreEqual(frac(double2(double.NegativeInfinity, -1E+20)), double2(double.NaN, 0.0), 64, false);
+            TestUtils.AreEqual(frac(double2(-100.3, 0.0)), double2(0.7, 0.0), 64, false);
+            TestUtils.AreEqual(frac(double2(100.8, double.PositiveInfinity)), double2(0.8, double.NaN), 64, false);
+            TestUtils.AreEqual(frac(double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_double3()
+        {
+            TestUtils.AreEqual(frac(double3(double.NegativeInfinity, -1E+20, -100.3)), double3(double.NaN, 0.0, 0.7), 64, false);
+            TestUtils.AreEqual(frac(double3(0.0, 100.8, double.PositiveInfinity)), double3(0.0, 0.8, double.NaN), 64, false);
+            TestUtils.AreEqual(frac(double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void frac_double4()
+        {
+            TestUtils.AreEqual(frac(double4(double.NegativeInfinity, -1E+20, -100.3, 0.0)), double4(double.NaN, 0.0, 0.7, 0.0), 64, false);
+            TestUtils.AreEqual(frac(double4(100.8, double.PositiveInfinity, double.NaN, double.NaN)), double4(0.8, double.NaN, double.NaN, double.NaN), 64, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_float()
+        {
+            TestUtils.AreEqual(lerp(-123.45f, 439.43f, -1.5f), -967.77f, 1, false);
+            TestUtils.AreEqual(lerp(-123.45f, 439.43f, 0.5f), 157.99f, 1, false);
+            TestUtils.AreEqual(lerp(-123.45f, 439.43f, 5.5f), 2972.39f, 1, false);
+            TestUtils.AreEqual(lerp(-123.45f, 439.43f, float.NaN), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_float2()
+        {
+            TestUtils.AreEqual(lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-1.5f, 0.5f)), float2(-967.77f, 157.99f), 1, false);
+            TestUtils.AreEqual(lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(5.5f, float.NaN)), float2(2972.39f, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_float3()
+        {
+            TestUtils.AreEqual(lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-1.5f, 0.5f, 5.5f)), float3(-967.77f, 157.99f, 2972.39f), 1, false);
+            TestUtils.AreEqual(lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_float4()
+        {
+            TestUtils.AreEqual(lerp(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f), float4(-1.5f, 0.5f, 5.5f, float.NaN)), float4(-967.77f, 157.99f, 2972.39f, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_double()
+        {
+            TestUtils.AreEqual(lerp(-123.45, 439.43, -1.5), -967.77, 1, false);
+            TestUtils.AreEqual(lerp(-123.45, 439.43, 0.5), 157.99, 1, false);
+            TestUtils.AreEqual(lerp(-123.45, 439.43, 5.5), 2972.39, 1, false);
+            TestUtils.AreEqual(lerp(-123.45, 439.43, double.NaN), double.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_double2()
+        {
+            TestUtils.AreEqual(lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-1.5, 0.5)), double2(-967.77, 157.99), 1, false);
+            TestUtils.AreEqual(lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(5.5, double.NaN)), double2(2972.39, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_double3()
+        {
+            TestUtils.AreEqual(lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-1.5, 0.5, 5.5)), double3(-967.77, 157.99, 2972.39), 1, false);
+            TestUtils.AreEqual(lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void lerp_double4()
+        {
+            TestUtils.AreEqual(lerp(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43), double4(-1.5, 0.5, 5.5, double.NaN)), double4(-967.77, 157.99, 2972.39, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_float()
+        {
+            TestUtils.AreEqual(unlerp(-123.45f, 439.43f, -254.3f), -0.232465178f, 4, false);
+            TestUtils.AreEqual(unlerp(-123.45f, 439.43f, 0f), 0.219318509f, 4, false);
+            TestUtils.AreEqual(unlerp(-123.45f, 439.43f, 632.1f), 1.34229326f, 4, false);
+            TestUtils.AreEqual(unlerp(123.4f, 123.4f, -430f), float.NegativeInfinity, 4, false);
+            TestUtils.AreEqual(unlerp(123.4f, 123.4f, 430f), float.PositiveInfinity, 4, false);
+            TestUtils.AreEqual(unlerp(439.43f, -123.45f, -254.3f), 1.23246515f, 4, false);
+            TestUtils.AreEqual(unlerp(439.43f, -123.45f, 0f), 0.7806815f, 4, false);
+            TestUtils.AreEqual(unlerp(439.43f, -123.45f, 632.1f), -0.3422932f, 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_float2()
+        {
+            TestUtils.AreEqual(unlerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-254.3f, 0f)), float2(-0.232465178f, 0.219318509f), 4, false);
+            TestUtils.AreEqual(unlerp(float2(-123.45f, 123.4f), float2(439.43f, 123.4f), float2(632.1f, -430f)), float2(1.34229326f, float.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(unlerp(float2(123.4f, 439.43f), float2(123.4f, -123.45f), float2(430f, -254.3f)), float2(float.PositiveInfinity, 1.23246515f), 4, false);
+            TestUtils.AreEqual(unlerp(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(0f, 632.1f)), float2(0.7806815f, -0.3422932f), 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_float3()
+        {
+            TestUtils.AreEqual(unlerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-254.3f, 0f, 632.1f)), float3(-0.232465178f, 0.219318509f, 1.34229326f), 4, false);
+            TestUtils.AreEqual(unlerp(float3(123.4f, 123.4f, 439.43f), float3(123.4f, 123.4f, -123.45f), float3(-430f, 430f, -254.3f)), float3(float.NegativeInfinity, float.PositiveInfinity, 1.23246515f), 4, false);
+            TestUtils.AreEqual(unlerp(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(0f, 632.1f, 632.1f)), float3(0.7806815f, -0.3422932f, -0.3422932f), 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_float4()
+        {
+            TestUtils.AreEqual(unlerp(float4(-123.45f, -123.45f, -123.45f, 123.4f), float4(439.43f, 439.43f, 439.43f, 123.4f), float4(-254.3f, 0f, 632.1f, -430f)), float4(-0.232465178f, 0.219318509f, 1.34229326f, float.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(unlerp(float4(123.4f, 439.43f, 439.43f, 439.43f), float4(123.4f, -123.45f, -123.45f, -123.45f), float4(430f, -254.3f, 0f, 632.1f)), float4(float.PositiveInfinity, 1.23246515f, 0.7806815f, -0.3422932f), 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_double()
+        {
+            TestUtils.AreEqual(unlerp(-123.45, 439.43, -254.3), -0.23246517907902217, 4, false);
+            TestUtils.AreEqual(unlerp(-123.45, 439.43, 0.0), 0.21931850483229107, 4, false);
+            TestUtils.AreEqual(unlerp(-123.45, 439.43, 632.1), 1.3422932063672541, 4, false);
+            TestUtils.AreEqual(unlerp(123.4, 123.4, -430.0), double.NegativeInfinity, 4, false);
+            TestUtils.AreEqual(unlerp(123.4, 123.4, 430.0), double.PositiveInfinity, 4, false);
+            TestUtils.AreEqual(unlerp(439.43, -123.45, -254.3), 1.2324651790790222, 4, false);
+            TestUtils.AreEqual(unlerp(439.43, -123.45, 0.0), 0.78068149516770891, 4, false);
+            TestUtils.AreEqual(unlerp(439.43, -123.45, 632.1), -0.34229320636725413, 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_double2()
+        {
+            TestUtils.AreEqual(unlerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-254.3, 0.0)), double2(-0.23246517907902217, 0.21931850483229107), 4, false);
+            TestUtils.AreEqual(unlerp(double2(-123.45, 123.4), double2(439.43, 123.4), double2(632.1, -430.0)), double2(1.3422932063672541, double.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(unlerp(double2(123.4, 439.43), double2(123.4, -123.45), double2(430.0, -254.3)), double2(double.PositiveInfinity, 1.2324651790790222), 4, false);
+            TestUtils.AreEqual(unlerp(double2(439.43, 439.43), double2(-123.45, -123.45), double2(0.0, 632.1)), double2(0.78068149516770891, -0.34229320636725413), 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_double3()
+        {
+            TestUtils.AreEqual(unlerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-254.3, 0.0, 632.1)), double3(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541), 4, false);
+            TestUtils.AreEqual(unlerp(double3(123.4, 123.4, 439.43), double3(123.4, 123.4, -123.45), double3(-430.0, 430.0, -254.3)), double3(double.NegativeInfinity, double.PositiveInfinity, 1.2324651790790222), 4, false);
+            TestUtils.AreEqual(unlerp(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(0.0, 632.1, 632.1)), double3(0.78068149516770891, -0.34229320636725413, -0.34229320636725413), 4, false);
+        }
+
+        [TestCompiler]
+        public static void unlerp_double4()
+        {
+            TestUtils.AreEqual(unlerp(double4(-123.45, -123.45, -123.45, 123.4), double4(439.43, 439.43, 439.43, 123.4), double4(-254.3, 0.0, 632.1, -430.0)), double4(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541, double.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(unlerp(double4(123.4, 439.43, 439.43, 439.43), double4(123.4, -123.45, -123.45, -123.45), double4(430.0, -254.3, 0.0, 632.1)), double4(double.PositiveInfinity, 1.2324651790790222, 0.78068149516770891, -0.34229320636725413), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_float()
+        {
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 541.3f, 631.5f, -200f), 529.0331f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 541.3f, 631.5f, -100f), 545.0578f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 541.3f, 631.5f, 500f), 641.2062f, 4, false);
+            TestUtils.AreEqual(remap(439.43f, -123.45f, 541.3f, 631.5f, -200f), 643.7669f, 4, false);
+            TestUtils.AreEqual(remap(439.43f, -123.45f, 541.3f, 631.5f, -100f), 627.7422f, 4, false);
+            TestUtils.AreEqual(remap(439.43f, -123.45f, 541.3f, 631.5f, 500f), 531.5938f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 631.5f, 541.3f, -200f), 643.7669f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 631.5f, 541.3f, -100f), 627.7422f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, 439.43f, 631.5f, 541.3f, 500f), 531.5938f, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, -123.45f, 541.3f, 631.5f, -200f), float.NegativeInfinity, 4, false);
+            TestUtils.AreEqual(remap(-123.45f, -123.45f, 541.3f, 631.5f, -100f), float.PositiveInfinity, 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_float2()
+        {
+            TestUtils.AreEqual(remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-200f, -100f)), float2(529.0331f, 545.0578f), 4, false);
+            TestUtils.AreEqual(remap(float2(-123.45f, 439.43f), float2(439.43f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(500f, -200f)), float2(641.2062f, 643.7669f), 4, false);
+            TestUtils.AreEqual(remap(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, 500f)), float2(627.7422f, 531.5938f), 4, false);
+            TestUtils.AreEqual(remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(631.5f, 631.5f), float2(541.3f, 541.3f), float2(-200f, -100f)), float2(643.7669f, 627.7422f), 4, false);
+            TestUtils.AreEqual(remap(float2(-123.45f, -123.45f), float2(439.43f, -123.45f), float2(631.5f, 541.3f), float2(541.3f, 631.5f), float2(500f, -200f)), float2(531.5938f, float.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(remap(float2(-123.45f, -123.45f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, -100f)), float2(float.PositiveInfinity, float.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_float3()
+        {
+            TestUtils.AreEqual(remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), float3(529.0331f, 545.0578f, 641.2062f), 4, false);
+            TestUtils.AreEqual(remap(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), float3(643.7669f, 627.7422f, 531.5938f), 4, false);
+            TestUtils.AreEqual(remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(631.5f, 631.5f, 631.5f), float3(541.3f, 541.3f, 541.3f), float3(-200f, -100f, 500f)), float3(643.7669f, 627.7422f, 531.5938f), 4, false);
+            TestUtils.AreEqual(remap(float3(-123.45f, -123.45f, -123.45f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, -100f)), float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_float4()
+        {
+            TestUtils.AreEqual(remap(float4(-123.45f, -123.45f, -123.45f, 439.43f), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(541.3f, 541.3f, 541.3f, 541.3f), float4(631.5f, 631.5f, 631.5f, 631.5f), float4(-200f, -100f, 500f, -200f)), float4(529.0331f, 545.0578f, 641.2062f, 643.7669f), 4, false);
+            TestUtils.AreEqual(remap(float4(439.43f, 439.43f, -123.45f, -123.45f), float4(-123.45f, -123.45f, 439.43f, 439.43f), float4(541.3f, 541.3f, 631.5f, 631.5f), float4(631.5f, 631.5f, 541.3f, 541.3f), float4(-100f, 500f, -200f, -100f)), float4(627.7422f, 531.5938f, 643.7669f, 627.7422f), 4, false);
+            TestUtils.AreEqual(remap(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, -123.45f, -123.45f, -123.45f), float4(631.5f, 541.3f, 541.3f, 541.3f), float4(541.3f, 631.5f, 631.5f, 631.5f), float4(500f, -200f, -100f, -100f)), float4(531.5938f, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_double()
+        {
+            TestUtils.AreEqual(remap(-123.45, 439.43, 541.3, 631.5, -200.0), 529.03306921546334, 4, false);
+            TestUtils.AreEqual(remap(-123.45, 439.43, 541.3, 631.5, -100.0), 545.057799175668, 4, false);
+            TestUtils.AreEqual(remap(-123.45, 439.43, 541.3, 631.5, 500.0), 641.206178936896, 4, false);
+            TestUtils.AreEqual(remap(439.43, -123.45, 541.3, 631.5, -200.0), 643.76693078453673, 4, false);
+            TestUtils.AreEqual(remap(439.43, -123.45, 541.3, 631.5, -100.0), 627.742200824332, 4, false);
+            TestUtils.AreEqual(remap(439.43, -123.45, 541.3, 631.5, 500.0), 531.59382106310409, 4, false);
+            TestUtils.AreEqual(remap(-123.45, 439.43, 631.5, 541.3, -200.0), 643.76693078453673, 4, false);
+            TestUtils.AreEqual(remap(-123.45, 439.43, 631.5, 541.3, -100.0), 627.742200824332, 4, false);
+            TestUtils.AreEqual(remap(-123.45, 439.43, 631.5, 541.3, 500.0), 531.59382106310409, 4, false);
+            TestUtils.AreEqual(remap(-123.45, -123.45, 541.3, 631.5, -200.0), double.NegativeInfinity, 4, false);
+            TestUtils.AreEqual(remap(-123.45, -123.45, 541.3, 631.5, -100.0), double.PositiveInfinity, 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_double2()
+        {
+            TestUtils.AreEqual(remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(541.3, 541.3), double2(631.5, 631.5), double2(-200.0, -100.0)), double2(529.03306921546334, 545.057799175668), 4, false);
+            TestUtils.AreEqual(remap(double2(-123.45, 439.43), double2(439.43, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(500.0, -200.0)), double2(641.206178936896, 643.76693078453673), 4, false);
+            TestUtils.AreEqual(remap(double2(439.43, 439.43), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, 500.0)), double2(627.742200824332, 531.59382106310409), 4, false);
+            TestUtils.AreEqual(remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(631.5, 631.5), double2(541.3, 541.3), double2(-200.0, -100.0)), double2(643.76693078453673, 627.742200824332), 4, false);
+            TestUtils.AreEqual(remap(double2(-123.45, -123.45), double2(439.43, -123.45), double2(631.5, 541.3), double2(541.3, 631.5), double2(500.0, -200.0)), double2(531.59382106310409, double.NegativeInfinity), 4, false);
+            TestUtils.AreEqual(remap(double2(-123.45, -123.45), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, -100.0)), double2(double.PositiveInfinity, double.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_double3()
+        {
+            TestUtils.AreEqual(remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), double3(529.03306921546334, 545.057799175668, 641.206178936896), 4, false);
+            TestUtils.AreEqual(remap(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), double3(643.76693078453673, 627.742200824332, 531.59382106310409), 4, false);
+            TestUtils.AreEqual(remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(631.5, 631.5, 631.5), double3(541.3, 541.3, 541.3), double3(-200.0, -100.0, 500.0)), double3(643.76693078453673, 627.742200824332, 531.59382106310409), 4, false);
+            TestUtils.AreEqual(remap(double3(-123.45, -123.45, -123.45), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, -100.0)), double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void remap_double4()
+        {
+            TestUtils.AreEqual(remap(double4(-123.45, -123.45, -123.45, 439.43), double4(439.43, 439.43, 439.43, -123.45), double4(541.3, 541.3, 541.3, 541.3), double4(631.5, 631.5, 631.5, 631.5), double4(-200.0, -100.0, 500.0, -200.0)), double4(529.03306921546334, 545.057799175668, 641.206178936896, 643.76693078453673), 4, false);
+            TestUtils.AreEqual(remap(double4(439.43, 439.43, -123.45, -123.45), double4(-123.45, -123.45, 439.43, 439.43), double4(541.3, 541.3, 631.5, 631.5), double4(631.5, 631.5, 541.3, 541.3), double4(-100.0, 500.0, -200.0, -100.0)), double4(627.742200824332, 531.59382106310409, 643.76693078453673, 627.742200824332), 4, false);
+            TestUtils.AreEqual(remap(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, -123.45, -123.45, -123.45), double4(631.5, 541.3, 541.3, 541.3), double4(541.3, 631.5, 631.5, 631.5), double4(500.0, -200.0, -100.0, -100.0)), double4(531.59382106310409, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), 4, false);
+        }
+
+        [TestCompiler]
+        public static void clamp_int()
+        {
+            TestUtils.AreEqual(clamp(-2147483648, -123, 439), -123);
+            TestUtils.AreEqual(clamp(-254, -123, 439), -123);
+            TestUtils.AreEqual(clamp(246, -123, 439), 246);
+            TestUtils.AreEqual(clamp(632, -123, 439), 439);
+            TestUtils.AreEqual(clamp(-254, 439, -123), 439);
+            TestUtils.AreEqual(clamp(246, 439, -123), 439);
+            TestUtils.AreEqual(clamp(632, 439, -123), 439);
+            TestUtils.AreEqual(clamp(2147483647, -123, 439), 439);
+        }
+
+        [TestCompiler]
+        public static void clamp_int2()
+        {
+            TestUtils.AreEqual(clamp(int2(-2147483648, -254), int2(-123, -123), int2(439, 439)), int2(-123, -123));
+            TestUtils.AreEqual(clamp(int2(246, 632), int2(-123, -123), int2(439, 439)), int2(246, 439));
+            TestUtils.AreEqual(clamp(int2(-254, 246), int2(439, 439), int2(-123, -123)), int2(439, 439));
+            TestUtils.AreEqual(clamp(int2(632, 2147483647), int2(439, -123), int2(-123, 439)), int2(439, 439));
+        }
+
+        [TestCompiler]
+        public static void clamp_int3()
+        {
+            TestUtils.AreEqual(clamp(int3(-2147483648, -254, 246), int3(-123, -123, -123), int3(439, 439, 439)), int3(-123, -123, 246));
+            TestUtils.AreEqual(clamp(int3(632, -254, 246), int3(-123, 439, 439), int3(439, -123, -123)), int3(439, 439, 439));
+            TestUtils.AreEqual(clamp(int3(632, 2147483647, 2147483647), int3(439, -123, -123), int3(-123, 439, 439)), int3(439, 439, 439));
+        }
+
+        [TestCompiler]
+        public static void clamp_int4()
+        {
+            TestUtils.AreEqual(clamp(int4(-2147483648, -254, 246, 632), int4(-123, -123, -123, -123), int4(439, 439, 439, 439)), int4(-123, -123, 246, 439));
+            TestUtils.AreEqual(clamp(int4(-254, 246, 632, 2147483647), int4(439, 439, 439, -123), int4(-123, -123, -123, 439)), int4(439, 439, 439, 439));
+        }
+
+        [TestCompiler]
+        public static void clamp_uint()
+        {
+            TestUtils.AreEqual(clamp(0u, 123u, 439u), 123u);
+            TestUtils.AreEqual(clamp(54u, 123u, 439u), 123u);
+            TestUtils.AreEqual(clamp(246u, 123u, 439u), 246u);
+            TestUtils.AreEqual(clamp(632u, 123u, 439u), 439u);
+            TestUtils.AreEqual(clamp(54u, 439u, 123u), 439u);
+            TestUtils.AreEqual(clamp(246u, 439u, 123u), 439u);
+            TestUtils.AreEqual(clamp(632u, 439u, 123u), 439u);
+            TestUtils.AreEqual(clamp(4294967295u, 123u, 439u), 439u);
+        }
+
+        [TestCompiler]
+        public static void clamp_uint2()
+        {
+            TestUtils.AreEqual(clamp(uint2(0u, 54u), uint2(123u, 123u), uint2(439u, 439u)), uint2(123u, 123u));
+            TestUtils.AreEqual(clamp(uint2(246u, 632u), uint2(123u, 123u), uint2(439u, 439u)), uint2(246u, 439u));
+            TestUtils.AreEqual(clamp(uint2(54u, 246u), uint2(439u, 439u), uint2(123u, 123u)), uint2(439u, 439u));
+            TestUtils.AreEqual(clamp(uint2(632u, 4294967295u), uint2(439u, 123u), uint2(123u, 439u)), uint2(439u, 439u));
+        }
+
+        [TestCompiler]
+        public static void clamp_uint3()
+        {
+            TestUtils.AreEqual(clamp(uint3(0u, 54u, 246u), uint3(123u, 123u, 123u), uint3(439u, 439u, 439u)), uint3(123u, 123u, 246u));
+            TestUtils.AreEqual(clamp(uint3(632u, 54u, 246u), uint3(123u, 439u, 439u), uint3(439u, 123u, 123u)), uint3(439u, 439u, 439u));
+            TestUtils.AreEqual(clamp(uint3(632u, 4294967295u, 4294967295u), uint3(439u, 123u, 123u), uint3(123u, 439u, 439u)), uint3(439u, 439u, 439u));
+        }
+
+        [TestCompiler]
+        public static void clamp_uint4()
+        {
+            TestUtils.AreEqual(clamp(uint4(0u, 54u, 246u, 632u), uint4(123u, 123u, 123u, 123u), uint4(439u, 439u, 439u, 439u)), uint4(123u, 123u, 246u, 439u));
+            TestUtils.AreEqual(clamp(uint4(54u, 246u, 632u, 4294967295u), uint4(439u, 439u, 439u, 123u), uint4(123u, 123u, 123u, 439u)), uint4(439u, 439u, 439u, 439u));
+        }
+
+        [TestCompiler]
+        public static void clamp_long()
+        {
+            TestUtils.AreEqual(clamp(-9223372036854775808L, -123L, 439L), -123L);
+            TestUtils.AreEqual(clamp(-254L, -123L, 439L), -123L);
+            TestUtils.AreEqual(clamp(246L, -123L, 439L), 246L);
+            TestUtils.AreEqual(clamp(632L, -123L, 439L), 439L);
+            TestUtils.AreEqual(clamp(-254L, 439L, -123L), 439L);
+            TestUtils.AreEqual(clamp(246L, 439L, -123L), 439L);
+            TestUtils.AreEqual(clamp(632L, 439L, -123L), 439L);
+            TestUtils.AreEqual(clamp(9223372036854775807L, -123L, 439L), 439L);
+        }
+
+        [TestCompiler]
+        public static void clamp_ulong()
+        {
+            TestUtils.AreEqual(clamp(0UL, 123UL, 439UL), 123UL);
+            TestUtils.AreEqual(clamp(54UL, 123UL, 439UL), 123UL);
+            TestUtils.AreEqual(clamp(246UL, 123UL, 439UL), 246UL);
+            TestUtils.AreEqual(clamp(632UL, 123UL, 439UL), 439UL);
+            TestUtils.AreEqual(clamp(54UL, 439UL, 123UL), 439UL);
+            TestUtils.AreEqual(clamp(246UL, 439UL, 123UL), 439UL);
+            TestUtils.AreEqual(clamp(632UL, 439UL, 123UL), 439UL);
+            TestUtils.AreEqual(clamp(18446744073709551615UL, 123UL, 439UL), 439UL);
+        }
+
+        [TestCompiler]
+        public static void clamp_float()
+        {
+            TestUtils.AreEqual(clamp(float.NegativeInfinity, -123.45f, 439.43f), -123.45f);
+            TestUtils.AreEqual(clamp(-254.3f, -123.45f, 439.43f), -123.45f);
+            TestUtils.AreEqual(clamp(246.3f, -123.45f, 439.43f), 246.3f);
+            TestUtils.AreEqual(clamp(632.1f, -123.45f, 439.43f), 439.43f);
+            TestUtils.AreEqual(clamp(-254.3f, 439.43f, -123.45f), 439.43f);
+            TestUtils.AreEqual(clamp(246.3f, 439.43f, -123.45f), 439.43f);
+            TestUtils.AreEqual(clamp(632.1f, 439.43f, -123.45f), 439.43f);
+            TestUtils.AreEqual(clamp(float.PositiveInfinity, -123.45f, 439.43f), 439.43f);
+            TestUtils.AreEqual(clamp(float.NaN, -123.45f, 439.43f), 439.43f);
+        }
+
+        [TestCompiler]
+        public static void clamp_float2()
+        {
+            TestUtils.AreEqual(clamp(float2(float.NegativeInfinity, -254.3f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)), float2(-123.45f, -123.45f));
+            TestUtils.AreEqual(clamp(float2(246.3f, 632.1f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)), float2(246.3f, 439.43f));
+            TestUtils.AreEqual(clamp(float2(-254.3f, 246.3f), float2(439.43f, 439.43f), float2(-123.45f, -123.45f)), float2(439.43f, 439.43f));
+            TestUtils.AreEqual(clamp(float2(632.1f, float.PositiveInfinity), float2(439.43f, -123.45f), float2(-123.45f, 439.43f)), float2(439.43f, 439.43f));
+            TestUtils.AreEqual(clamp(float2(float.NaN, float.NaN), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)), float2(439.43f, 439.43f));
+        }
+
+        [TestCompiler]
+        public static void clamp_float3()
+        {
+            TestUtils.AreEqual(clamp(float3(float.NegativeInfinity, -254.3f, 246.3f), float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f)), float3(-123.45f, -123.45f, 246.3f));
+            TestUtils.AreEqual(clamp(float3(632.1f, -254.3f, 246.3f), float3(-123.45f, 439.43f, 439.43f), float3(439.43f, -123.45f, -123.45f)), float3(439.43f, 439.43f, 439.43f));
+            TestUtils.AreEqual(clamp(float3(632.1f, float.PositiveInfinity, float.NaN), float3(439.43f, -123.45f, -123.45f), float3(-123.45f, 439.43f, 439.43f)), float3(439.43f, 439.43f, 439.43f));
+        }
+
+        [TestCompiler]
+        public static void clamp_float4()
+        {
+            TestUtils.AreEqual(clamp(float4(float.NegativeInfinity, -254.3f, 246.3f, 632.1f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)), float4(-123.45f, -123.45f, 246.3f, 439.43f));
+            TestUtils.AreEqual(clamp(float4(-254.3f, 246.3f, 632.1f, float.PositiveInfinity), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(-123.45f, -123.45f, -123.45f, 439.43f)), float4(439.43f, 439.43f, 439.43f, 439.43f));
+            TestUtils.AreEqual(clamp(float4(float.NaN, float.NaN, float.NaN, float.NaN), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)), float4(439.43f, 439.43f, 439.43f, 439.43f));
+        }
+
+        [TestCompiler]
+        public static void clamp_double()
+        {
+            TestUtils.AreEqual(clamp(double.NegativeInfinity, -123.45, 439.43), -123.45);
+            TestUtils.AreEqual(clamp(-254.3, -123.45, 439.43), -123.45);
+            TestUtils.AreEqual(clamp(246.3, -123.45, 439.43), 246.3);
+            TestUtils.AreEqual(clamp(632.1, -123.45, 439.43), 439.43);
+            TestUtils.AreEqual(clamp(-254.3, 439.43, -123.45), 439.43);
+            TestUtils.AreEqual(clamp(246.3, 439.43, -123.45), 439.43);
+            TestUtils.AreEqual(clamp(632.1, 439.43, -123.45), 439.43);
+            TestUtils.AreEqual(clamp(double.PositiveInfinity, -123.45, 439.43), 439.43);
+            TestUtils.AreEqual(clamp(double.NaN, -123.45, 439.43), 439.43);
+        }
+
+        [TestCompiler]
+        public static void clamp_double2()
+        {
+            TestUtils.AreEqual(clamp(double2(double.NegativeInfinity, -254.3), double2(-123.45, -123.45), double2(439.43, 439.43)), double2(-123.45, -123.45));
+            TestUtils.AreEqual(clamp(double2(246.3, 632.1), double2(-123.45, -123.45), double2(439.43, 439.43)), double2(246.3, 439.43));
+            TestUtils.AreEqual(clamp(double2(-254.3, 246.3), double2(439.43, 439.43), double2(-123.45, -123.45)), double2(439.43, 439.43));
+            TestUtils.AreEqual(clamp(double2(632.1, double.PositiveInfinity), double2(439.43, -123.45), double2(-123.45, 439.43)), double2(439.43, 439.43));
+            TestUtils.AreEqual(clamp(double2(double.NaN, double.NaN), double2(-123.45, -123.45), double2(439.43, 439.43)), double2(439.43, 439.43));
+        }
+
+        [TestCompiler]
+        public static void clamp_double3()
+        {
+            TestUtils.AreEqual(clamp(double3(double.NegativeInfinity, -254.3, 246.3), double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43)), double3(-123.45, -123.45, 246.3));
+            TestUtils.AreEqual(clamp(double3(632.1, -254.3, 246.3), double3(-123.45, 439.43, 439.43), double3(439.43, -123.45, -123.45)), double3(439.43, 439.43, 439.43));
+            TestUtils.AreEqual(clamp(double3(632.1, double.PositiveInfinity, double.NaN), double3(439.43, -123.45, -123.45), double3(-123.45, 439.43, 439.43)), double3(439.43, 439.43, 439.43));
+        }
+
+        [TestCompiler]
+        public static void clamp_double4()
+        {
+            TestUtils.AreEqual(clamp(double4(double.NegativeInfinity, -254.3, 246.3, 632.1), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)), double4(-123.45, -123.45, 246.3, 439.43));
+            TestUtils.AreEqual(clamp(double4(-254.3, 246.3, 632.1, double.PositiveInfinity), double4(439.43, 439.43, 439.43, -123.45), double4(-123.45, -123.45, -123.45, 439.43)), double4(439.43, 439.43, 439.43, 439.43));
+            TestUtils.AreEqual(clamp(double4(double.NaN, double.NaN, double.NaN, double.NaN), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)), double4(439.43, 439.43, 439.43, 439.43));
+        }
+
+        [TestCompiler]
+        public static void saturate_float()
+        {
+            TestUtils.AreEqual(saturate(float.NegativeInfinity), 0f);
+            TestUtils.AreEqual(saturate(-123.45f), 0f);
+            TestUtils.AreEqual(saturate(0f), 0f);
+            TestUtils.AreEqual(saturate(0.5f), 0.5f);
+            TestUtils.AreEqual(saturate(1f), 1f);
+            TestUtils.AreEqual(saturate(123.45f), 1f);
+            TestUtils.AreEqual(saturate(float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(saturate(float.NaN), 1f);
+        }
+
+        [TestCompiler]
+        public static void saturate_float2()
+        {
+            TestUtils.AreEqual(saturate(float2(float.NegativeInfinity, -123.45f)), float2(0f, 0f));
+            TestUtils.AreEqual(saturate(float2(0f, 0.5f)), float2(0f, 0.5f));
+            TestUtils.AreEqual(saturate(float2(1f, 123.45f)), float2(1f, 1f));
+            TestUtils.AreEqual(saturate(float2(float.PositiveInfinity, float.NaN)), float2(1f, 1f));
+        }
+
+        [TestCompiler]
+        public static void saturate_float3()
+        {
+            TestUtils.AreEqual(saturate(float3(float.NegativeInfinity, -123.45f, 0f)), float3(0f, 0f, 0f));
+            TestUtils.AreEqual(saturate(float3(0.5f, 1f, 123.45f)), float3(0.5f, 1f, 1f));
+            TestUtils.AreEqual(saturate(float3(float.PositiveInfinity, float.NaN, float.NaN)), float3(1f, 1f, 1f));
+        }
+
+        [TestCompiler]
+        public static void saturate_float4()
+        {
+            TestUtils.AreEqual(saturate(float4(float.NegativeInfinity, -123.45f, 0f, 0.5f)), float4(0f, 0f, 0f, 0.5f));
+            TestUtils.AreEqual(saturate(float4(1f, 123.45f, float.PositiveInfinity, float.NaN)), float4(1f, 1f, 1f, 1f));
+        }
+
+        [TestCompiler]
+        public static void saturate_double()
+        {
+            TestUtils.AreEqual(saturate(double.NegativeInfinity), 0.0);
+            TestUtils.AreEqual(saturate(-123.45), 0.0);
+            TestUtils.AreEqual(saturate(0.0), 0.0);
+            TestUtils.AreEqual(saturate(0.5), 0.5);
+            TestUtils.AreEqual(saturate(1.0), 1.0);
+            TestUtils.AreEqual(saturate(123.45), 1.0);
+            TestUtils.AreEqual(saturate(double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(saturate(double.NaN), 1.0);
+        }
+
+        [TestCompiler]
+        public static void saturate_double2()
+        {
+            TestUtils.AreEqual(saturate(double2(double.NegativeInfinity, -123.45)), double2(0.0, 0.0));
+            TestUtils.AreEqual(saturate(double2(0.0, 0.5)), double2(0.0, 0.5));
+            TestUtils.AreEqual(saturate(double2(1.0, 123.45)), double2(1.0, 1.0));
+            TestUtils.AreEqual(saturate(double2(double.PositiveInfinity, double.NaN)), double2(1.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void saturate_double3()
+        {
+            TestUtils.AreEqual(saturate(double3(double.NegativeInfinity, -123.45, 0.0)), double3(0.0, 0.0, 0.0));
+            TestUtils.AreEqual(saturate(double3(0.5, 1.0, 123.45)), double3(0.5, 1.0, 1.0));
+            TestUtils.AreEqual(saturate(double3(double.PositiveInfinity, double.NaN, double.NaN)), double3(1.0, 1.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void saturate_double4()
+        {
+            TestUtils.AreEqual(saturate(double4(double.NegativeInfinity, -123.45, 0.0, 0.5)), double4(0.0, 0.0, 0.0, 0.5));
+            TestUtils.AreEqual(saturate(double4(1.0, 123.45, double.PositiveInfinity, double.NaN)), double4(1.0, 1.0, 1.0, 1.0));
+        }
+
+        [TestCompiler]
+        public static void step_float()
+        {
+            TestUtils.AreEqual(step(-123.45f, float.NegativeInfinity), 0f);
+            TestUtils.AreEqual(step(-123.45f, -200f), 0f);
+            TestUtils.AreEqual(step(-123.45f, 200f), 1f);
+            TestUtils.AreEqual(step(-123.45f, float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(step(-123.45f, float.NaN), 0f);
+            TestUtils.AreEqual(step(123.45f, float.NegativeInfinity), 0f);
+            TestUtils.AreEqual(step(123.45f, -200f), 0f);
+            TestUtils.AreEqual(step(123.45f, 200f), 1f);
+            TestUtils.AreEqual(step(123.45f, float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(step(123.45f, float.NaN), 0f);
+            TestUtils.AreEqual(step(float.NegativeInfinity, float.NegativeInfinity), 1f);
+            TestUtils.AreEqual(step(float.NegativeInfinity, -200f), 1f);
+            TestUtils.AreEqual(step(float.NegativeInfinity, 200f), 1f);
+            TestUtils.AreEqual(step(float.NegativeInfinity, float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(step(float.NegativeInfinity, float.NaN), 0f);
+            TestUtils.AreEqual(step(float.PositiveInfinity, float.NegativeInfinity), 0f);
+            TestUtils.AreEqual(step(float.PositiveInfinity, -200f), 0f);
+            TestUtils.AreEqual(step(float.PositiveInfinity, 200f), 0f);
+            TestUtils.AreEqual(step(float.PositiveInfinity, float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(step(float.PositiveInfinity, float.NaN), 0f);
+            TestUtils.AreEqual(step(float.NaN, float.NegativeInfinity), 0f);
+            TestUtils.AreEqual(step(float.NaN, -200f), 0f);
+            TestUtils.AreEqual(step(float.NaN, 200f), 0f);
+            TestUtils.AreEqual(step(float.NaN, float.PositiveInfinity), 0f);
+            TestUtils.AreEqual(step(float.NaN, float.NaN), 0f);
+        }
+
+        [TestCompiler]
+        public static void step_float2()
+        {
+            TestUtils.AreEqual(step(float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(-123.45f, -123.45f), float2(200f, float.PositiveInfinity)), float2(1f, 1f));
+            TestUtils.AreEqual(step(float2(-123.45f, 123.45f), float2(float.NaN, float.NegativeInfinity)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(123.45f, 123.45f), float2(-200f, 200f)), float2(0f, 1f));
+            TestUtils.AreEqual(step(float2(123.45f, 123.45f), float2(float.PositiveInfinity, float.NaN)), float2(1f, 0f));
+            TestUtils.AreEqual(step(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -200f)), float2(1f, 1f));
+            TestUtils.AreEqual(step(float2(float.NegativeInfinity, float.NegativeInfinity), float2(200f, float.PositiveInfinity)), float2(1f, 1f));
+            TestUtils.AreEqual(step(float2(float.NegativeInfinity, float.PositiveInfinity), float2(float.NaN, float.NegativeInfinity)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(float.PositiveInfinity, float.PositiveInfinity), float2(-200f, 200f)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(float.PositiveInfinity, float.PositiveInfinity), float2(float.PositiveInfinity, float.NaN)), float2(1f, 0f));
+            TestUtils.AreEqual(step(float2(float.NaN, float.NaN), float2(float.NegativeInfinity, -200f)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(float.NaN, float.NaN), float2(200f, float.PositiveInfinity)), float2(0f, 0f));
+            TestUtils.AreEqual(step(float2(float.NaN, float.NaN), float2(float.NaN, float.NaN)), float2(0f, 0f));
+        }
+
+        [TestCompiler]
+        public static void step_float3()
+        {
+            TestUtils.AreEqual(step(float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, 200f)), float3(0f, 0f, 1f));
+            TestUtils.AreEqual(step(float3(-123.45f, -123.45f, 123.45f), float3(float.PositiveInfinity, float.NaN, float.NegativeInfinity)), float3(1f, 0f, 0f));
+            TestUtils.AreEqual(step(float3(123.45f, 123.45f, 123.45f), float3(-200f, 200f, float.PositiveInfinity)), float3(0f, 1f, 1f));
+            TestUtils.AreEqual(step(float3(123.45f, float.NegativeInfinity, float.NegativeInfinity), float3(float.NaN, float.NegativeInfinity, -200f)), float3(0f, 1f, 1f));
+            TestUtils.AreEqual(step(float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), float3(200f, float.PositiveInfinity, float.NaN)), float3(1f, 1f, 0f));
+            TestUtils.AreEqual(step(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), float3(float.NegativeInfinity, -200f, 200f)), float3(0f, 0f, 0f));
+            TestUtils.AreEqual(step(float3(float.PositiveInfinity, float.PositiveInfinity, float.NaN), float3(float.PositiveInfinity, float.NaN, float.NegativeInfinity)), float3(1f, 0f, 0f));
+            TestUtils.AreEqual(step(float3(float.NaN, float.NaN, float.NaN), float3(-200f, 200f, float.PositiveInfinity)), float3(0f, 0f, 0f));
+            TestUtils.AreEqual(step(float3(float.NaN, float.NaN, float.NaN), float3(float.NaN, float.NaN, float.NaN)), float3(0f, 0f, 0f));
+        }
+
+        [TestCompiler]
+        public static void step_float4()
+        {
+            TestUtils.AreEqual(step(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity)), float4(0f, 0f, 1f, 1f));
+            TestUtils.AreEqual(step(float4(-123.45f, 123.45f, 123.45f, 123.45f), float4(float.NaN, float.NegativeInfinity, -200f, 200f)), float4(0f, 0f, 0f, 1f));
+            TestUtils.AreEqual(step(float4(123.45f, 123.45f, float.NegativeInfinity, float.NegativeInfinity), float4(float.PositiveInfinity, float.NaN, float.NegativeInfinity, -200f)), float4(1f, 0f, 1f, 1f));
+            TestUtils.AreEqual(step(float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.PositiveInfinity), float4(200f, float.PositiveInfinity, float.NaN, float.NegativeInfinity)), float4(1f, 1f, 0f, 0f));
+            TestUtils.AreEqual(step(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), float4(-200f, 200f, float.PositiveInfinity, float.NaN)), float4(0f, 0f, 1f, 0f));
+            TestUtils.AreEqual(step(float4(float.NaN, float.NaN, float.NaN, float.NaN), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity)), float4(0f, 0f, 0f, 0f));
+            TestUtils.AreEqual(step(float4(float.NaN, float.NaN, float.NaN, float.NaN), float4(float.NaN, float.NaN, float.NaN, float.NaN)), float4(0f, 0f, 0f, 0f));
+        }
+
+        [TestCompiler]
+        public static void step_double()
+        {
+            TestUtils.AreEqual(step(-123.45, double.NegativeInfinity), 0.0);
+            TestUtils.AreEqual(step(-123.45, -200.0), 0.0);
+            TestUtils.AreEqual(step(-123.45, 200.0), 1.0);
+            TestUtils.AreEqual(step(-123.45, double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(step(-123.45, double.NaN), 0.0);
+            TestUtils.AreEqual(step(123.45, double.NegativeInfinity), 0.0);
+            TestUtils.AreEqual(step(123.45, -200.0), 0.0);
+            TestUtils.AreEqual(step(123.45, 200.0), 1.0);
+            TestUtils.AreEqual(step(123.45, double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(step(123.45, double.NaN), 0.0);
+            TestUtils.AreEqual(step(double.NegativeInfinity, double.NegativeInfinity), 1.0);
+            TestUtils.AreEqual(step(double.NegativeInfinity, -200.0), 1.0);
+            TestUtils.AreEqual(step(double.NegativeInfinity, 200.0), 1.0);
+            TestUtils.AreEqual(step(double.NegativeInfinity, double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(step(double.NegativeInfinity, double.NaN), 0.0);
+            TestUtils.AreEqual(step(double.PositiveInfinity, double.NegativeInfinity), 0.0);
+            TestUtils.AreEqual(step(double.PositiveInfinity, -200.0), 0.0);
+            TestUtils.AreEqual(step(double.PositiveInfinity, 200.0), 0.0);
+            TestUtils.AreEqual(step(double.PositiveInfinity, double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(step(double.PositiveInfinity, double.NaN), 0.0);
+            TestUtils.AreEqual(step(double.NaN, double.NegativeInfinity), 0.0);
+            TestUtils.AreEqual(step(double.NaN, -200.0), 0.0);
+            TestUtils.AreEqual(step(double.NaN, 200.0), 0.0);
+            TestUtils.AreEqual(step(double.NaN, double.PositiveInfinity), 0.0);
+            TestUtils.AreEqual(step(double.NaN, double.NaN), 0.0);
+        }
+
+        [TestCompiler]
+        public static void step_double2()
+        {
+            TestUtils.AreEqual(step(double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(-123.45, -123.45), double2(200.0, double.PositiveInfinity)), double2(1.0, 1.0));
+            TestUtils.AreEqual(step(double2(-123.45, 123.45), double2(double.NaN, double.NegativeInfinity)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(123.45, 123.45), double2(-200.0, 200.0)), double2(0.0, 1.0));
+            TestUtils.AreEqual(step(double2(123.45, 123.45), double2(double.PositiveInfinity, double.NaN)), double2(1.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -200.0)), double2(1.0, 1.0));
+            TestUtils.AreEqual(step(double2(double.NegativeInfinity, double.NegativeInfinity), double2(200.0, double.PositiveInfinity)), double2(1.0, 1.0));
+            TestUtils.AreEqual(step(double2(double.NegativeInfinity, double.PositiveInfinity), double2(double.NaN, double.NegativeInfinity)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.PositiveInfinity, double.PositiveInfinity), double2(-200.0, 200.0)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.PositiveInfinity, double.PositiveInfinity), double2(double.PositiveInfinity, double.NaN)), double2(1.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.NaN, double.NaN), double2(double.NegativeInfinity, -200.0)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.NaN, double.NaN), double2(200.0, double.PositiveInfinity)), double2(0.0, 0.0));
+            TestUtils.AreEqual(step(double2(double.NaN, double.NaN), double2(double.NaN, double.NaN)), double2(0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void step_double3()
+        {
+            TestUtils.AreEqual(step(double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, 200.0)), double3(0.0, 0.0, 1.0));
+            TestUtils.AreEqual(step(double3(-123.45, -123.45, 123.45), double3(double.PositiveInfinity, double.NaN, double.NegativeInfinity)), double3(1.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double3(123.45, 123.45, 123.45), double3(-200.0, 200.0, double.PositiveInfinity)), double3(0.0, 1.0, 1.0));
+            TestUtils.AreEqual(step(double3(123.45, double.NegativeInfinity, double.NegativeInfinity), double3(double.NaN, double.NegativeInfinity, -200.0)), double3(0.0, 1.0, 1.0));
+            TestUtils.AreEqual(step(double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity), double3(200.0, double.PositiveInfinity, double.NaN)), double3(1.0, 1.0, 0.0));
+            TestUtils.AreEqual(step(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), double3(double.NegativeInfinity, -200.0, 200.0)), double3(0.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double3(double.PositiveInfinity, double.PositiveInfinity, double.NaN), double3(double.PositiveInfinity, double.NaN, double.NegativeInfinity)), double3(1.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double3(double.NaN, double.NaN, double.NaN), double3(-200.0, 200.0, double.PositiveInfinity)), double3(0.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double3(double.NaN, double.NaN, double.NaN), double3(double.NaN, double.NaN, double.NaN)), double3(0.0, 0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void step_double4()
+        {
+            TestUtils.AreEqual(step(double4(-123.45, -123.45, -123.45, -123.45), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity)), double4(0.0, 0.0, 1.0, 1.0));
+            TestUtils.AreEqual(step(double4(-123.45, 123.45, 123.45, 123.45), double4(double.NaN, double.NegativeInfinity, -200.0, 200.0)), double4(0.0, 0.0, 0.0, 1.0));
+            TestUtils.AreEqual(step(double4(123.45, 123.45, double.NegativeInfinity, double.NegativeInfinity), double4(double.PositiveInfinity, double.NaN, double.NegativeInfinity, -200.0)), double4(1.0, 0.0, 1.0, 1.0));
+            TestUtils.AreEqual(step(double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.PositiveInfinity), double4(200.0, double.PositiveInfinity, double.NaN, double.NegativeInfinity)), double4(1.0, 1.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), double4(-200.0, 200.0, double.PositiveInfinity, double.NaN)), double4(0.0, 0.0, 1.0, 0.0));
+            TestUtils.AreEqual(step(double4(double.NaN, double.NaN, double.NaN, double.NaN), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity)), double4(0.0, 0.0, 0.0, 0.0));
+            TestUtils.AreEqual(step(double4(double.NaN, double.NaN, double.NaN, double.NaN), double4(double.NaN, double.NaN, double.NaN, double.NaN)), double4(0.0, 0.0, 0.0, 0.0));
+        }
+
+        [TestCompiler]
+        public static void min_int()
+        {
+            TestUtils.AreEqual(min(-2147483648, -2147483648), -2147483648);
+            TestUtils.AreEqual(min(-2147483648, -1), -2147483648);
+            TestUtils.AreEqual(min(-1, -2147483648), -2147483648);
+            TestUtils.AreEqual(min(-1234, -3456), -3456);
+            TestUtils.AreEqual(min(-3456, -1234), -3456);
+            TestUtils.AreEqual(min(-1234, 3456), -1234);
+            TestUtils.AreEqual(min(3456, -1234), -1234);
+            TestUtils.AreEqual(min(1234, 3456), 1234);
+            TestUtils.AreEqual(min(3456, 1234), 1234);
+            TestUtils.AreEqual(min(1, 2147483647), 1);
+            TestUtils.AreEqual(min(2147483647, 1), 1);
+            TestUtils.AreEqual(min(2147483647, -2147483648), -2147483648);
+            TestUtils.AreEqual(min(2147483647, 2147483647), 2147483647);
+        }
+
+        [TestCompiler]
+        public static void min_int2()
+        {
+            TestUtils.AreEqual(min(int2(-2147483648, -2147483648), int2(-2147483648, -1)), int2(-2147483648, -2147483648));
+            TestUtils.AreEqual(min(int2(-1, -1234), int2(-2147483648, -3456)), int2(-2147483648, -3456));
+            TestUtils.AreEqual(min(int2(-3456, -1234), int2(-1234, 3456)), int2(-3456, -1234));
+            TestUtils.AreEqual(min(int2(3456, 1234), int2(-1234, 3456)), int2(-1234, 1234));
+            TestUtils.AreEqual(min(int2(3456, 1), int2(1234, 2147483647)), int2(1234, 1));
+            TestUtils.AreEqual(min(int2(2147483647, 2147483647), int2(1, -2147483648)), int2(1, -2147483648));
+            TestUtils.AreEqual(min(int2(2147483647, 2147483647), int2(2147483647, 2147483647)), int2(2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void min_int3()
+        {
+            TestUtils.AreEqual(min(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)), int3(-2147483648, -2147483648, -2147483648));
+            TestUtils.AreEqual(min(int3(-1234, -3456, -1234), int3(-3456, -1234, 3456)), int3(-3456, -3456, -1234));
+            TestUtils.AreEqual(min(int3(3456, 1234, 3456), int3(-1234, 3456, 1234)), int3(-1234, 1234, 1234));
+            TestUtils.AreEqual(min(int3(1, 2147483647, 2147483647), int3(2147483647, 1, -2147483648)), int3(1, 1, -2147483648));
+            TestUtils.AreEqual(min(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)), int3(2147483647, 2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void min_int4()
+        {
+            TestUtils.AreEqual(min(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)), int4(-2147483648, -2147483648, -2147483648, -3456));
+            TestUtils.AreEqual(min(int4(-3456, -1234, 3456, 1234), int4(-1234, 3456, -1234, 3456)), int4(-3456, -1234, -1234, 1234));
+            TestUtils.AreEqual(min(int4(3456, 1, 2147483647, 2147483647), int4(1234, 2147483647, 1, -2147483648)), int4(1234, 1, 1, -2147483648));
+            TestUtils.AreEqual(min(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)), int4(2147483647, 2147483647, 2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void min_uint()
+        {
+            TestUtils.AreEqual(min(1234u, 3456u), 1234u);
+            TestUtils.AreEqual(min(3456u, 1234u), 1234u);
+            TestUtils.AreEqual(min(4294967040u, 7u), 7u);
+            TestUtils.AreEqual(min(7u, 4294967040u), 7u);
+            TestUtils.AreEqual(min(1u, 4294967295u), 1u);
+            TestUtils.AreEqual(min(4294967295u, 1u), 1u);
+            TestUtils.AreEqual(min(4294967295u, 4294967295u), 4294967295u);
+        }
+
+        [TestCompiler]
+        public static void min_uint2()
+        {
+            TestUtils.AreEqual(min(uint2(1234u, 3456u), uint2(3456u, 1234u)), uint2(1234u, 1234u));
+            TestUtils.AreEqual(min(uint2(4294967040u, 7u), uint2(7u, 4294967040u)), uint2(7u, 7u));
+            TestUtils.AreEqual(min(uint2(1u, 4294967295u), uint2(4294967295u, 1u)), uint2(1u, 1u));
+            TestUtils.AreEqual(min(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)), uint2(4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void min_uint3()
+        {
+            TestUtils.AreEqual(min(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)), uint3(1234u, 1234u, 7u));
+            TestUtils.AreEqual(min(uint3(7u, 1u, 4294967295u), uint3(4294967040u, 4294967295u, 1u)), uint3(7u, 1u, 1u));
+            TestUtils.AreEqual(min(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)), uint3(4294967295u, 4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void min_uint4()
+        {
+            TestUtils.AreEqual(min(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)), uint4(1234u, 1234u, 7u, 7u));
+            TestUtils.AreEqual(min(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)), uint4(1u, 1u, 4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void min_long()
+        {
+            TestUtils.AreEqual(min(-9223372036854775808L, -9223372036854775808L), -9223372036854775808L);
+            TestUtils.AreEqual(min(-9223372036854775808L, -1L), -9223372036854775808L);
+            TestUtils.AreEqual(min(-1L, -9223372036854775808L), -9223372036854775808L);
+            TestUtils.AreEqual(min(-1234L, -3456L), -3456L);
+            TestUtils.AreEqual(min(-3456L, -1234L), -3456L);
+            TestUtils.AreEqual(min(-1234L, 3456L), -1234L);
+            TestUtils.AreEqual(min(3456L, -1234L), -1234L);
+            TestUtils.AreEqual(min(1234L, 3456L), 1234L);
+            TestUtils.AreEqual(min(3456L, 1234L), 1234L);
+            TestUtils.AreEqual(min(1L, 9223372036854775807L), 1L);
+            TestUtils.AreEqual(min(9223372036854775807L, 1L), 1L);
+            TestUtils.AreEqual(min(9223372036854775807L, -9223372036854775808L), -9223372036854775808L);
+            TestUtils.AreEqual(min(9223372036854775807L, 9223372036854775807L), 9223372036854775807L);
+        }
+
+        [TestCompiler]
+        public static void min_ulong()
+        {
+            TestUtils.AreEqual(min(1234UL, 3456UL), 1234UL);
+            TestUtils.AreEqual(min(3456UL, 1234UL), 1234UL);
+            TestUtils.AreEqual(min(18446744073709551360UL, 7UL), 7UL);
+            TestUtils.AreEqual(min(7UL, 18446744073709551360UL), 7UL);
+            TestUtils.AreEqual(min(1UL, 18446744073709551615UL), 1UL);
+            TestUtils.AreEqual(min(18446744073709551615UL, 1UL), 1UL);
+            TestUtils.AreEqual(min(18446744073709551615UL, 18446744073709551615UL), 18446744073709551615UL);
+        }
+
+        [TestCompiler]
+        public static void min_float()
+        {
+            TestUtils.AreEqual(min(float.NegativeInfinity, float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(min(float.NegativeInfinity, -1f), float.NegativeInfinity);
+            TestUtils.AreEqual(min(-1f, float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(min(-1234.56f, -3456.7f), -3456.7f);
+            TestUtils.AreEqual(min(-3456.7f, -1234.56f), -3456.7f);
+            TestUtils.AreEqual(min(-1234.56f, 3456.7f), -1234.56f);
+            TestUtils.AreEqual(min(3456.7f, -1234.56f), -1234.56f);
+            TestUtils.AreEqual(min(1234.56f, 3456.7f), 1234.56f);
+            TestUtils.AreEqual(min(3456.7f, 1234.56f), 1234.56f);
+            TestUtils.AreEqual(min(1f, float.PositiveInfinity), 1f);
+            TestUtils.AreEqual(min(float.PositiveInfinity, 1f), 1f);
+            TestUtils.AreEqual(min(float.PositiveInfinity, float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(min(float.PositiveInfinity, float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(min(float.NaN, 2.3f), 2.3f);
+            TestUtils.AreEqual(min(2.3f, float.NaN), 2.3f);
+            TestUtils.AreEqual(min(float.NaN, float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void min_float2()
+        {
+            TestUtils.AreEqual(min(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)), float2(float.NegativeInfinity, float.NegativeInfinity));
+            TestUtils.AreEqual(min(float2(-1f, -1234.56f), float2(float.NegativeInfinity, -3456.7f)), float2(float.NegativeInfinity, -3456.7f));
+            TestUtils.AreEqual(min(float2(-3456.7f, -1234.56f), float2(-1234.56f, 3456.7f)), float2(-3456.7f, -1234.56f));
+            TestUtils.AreEqual(min(float2(3456.7f, 1234.56f), float2(-1234.56f, 3456.7f)), float2(-1234.56f, 1234.56f));
+            TestUtils.AreEqual(min(float2(3456.7f, 1f), float2(1234.56f, float.PositiveInfinity)), float2(1234.56f, 1f));
+            TestUtils.AreEqual(min(float2(float.PositiveInfinity, float.PositiveInfinity), float2(1f, float.NegativeInfinity)), float2(1f, float.NegativeInfinity));
+            TestUtils.AreEqual(min(float2(float.PositiveInfinity, float.NaN), float2(float.PositiveInfinity, 2.3f)), float2(float.PositiveInfinity, 2.3f));
+            TestUtils.AreEqual(min(float2(2.3f, float.NaN), float2(float.NaN, float.NaN)), float2(2.3f, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void min_float3()
+        {
+            TestUtils.AreEqual(min(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity));
+            TestUtils.AreEqual(min(float3(-1234.56f, -3456.7f, -1234.56f), float3(-3456.7f, -1234.56f, 3456.7f)), float3(-3456.7f, -3456.7f, -1234.56f));
+            TestUtils.AreEqual(min(float3(3456.7f, 1234.56f, 3456.7f), float3(-1234.56f, 3456.7f, 1234.56f)), float3(-1234.56f, 1234.56f, 1234.56f));
+            TestUtils.AreEqual(min(float3(1f, float.PositiveInfinity, float.PositiveInfinity), float3(float.PositiveInfinity, 1f, float.NegativeInfinity)), float3(1f, 1f, float.NegativeInfinity));
+            TestUtils.AreEqual(min(float3(float.PositiveInfinity, float.NaN, 2.3f), float3(float.PositiveInfinity, 2.3f, float.NaN)), float3(float.PositiveInfinity, 2.3f, 2.3f));
+            TestUtils.AreEqual(min(float3(float.NaN, float.NaN, float.NaN), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void min_float4()
+        {
+            TestUtils.AreEqual(min(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -3456.7f));
+            TestUtils.AreEqual(min(float4(-3456.7f, -1234.56f, 3456.7f, 1234.56f), float4(-1234.56f, 3456.7f, -1234.56f, 3456.7f)), float4(-3456.7f, -1234.56f, -1234.56f, 1234.56f));
+            TestUtils.AreEqual(min(float4(3456.7f, 1f, float.PositiveInfinity, float.PositiveInfinity), float4(1234.56f, float.PositiveInfinity, 1f, float.NegativeInfinity)), float4(1234.56f, 1f, 1f, float.NegativeInfinity));
+            TestUtils.AreEqual(min(float4(float.PositiveInfinity, float.NaN, 2.3f, float.NaN), float4(float.PositiveInfinity, 2.3f, float.NaN, float.NaN)), float4(float.PositiveInfinity, 2.3f, 2.3f, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void min_double()
+        {
+            TestUtils.AreEqual(min(double.NegativeInfinity, double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(min(double.NegativeInfinity, -1.0), double.NegativeInfinity);
+            TestUtils.AreEqual(min(-1.0, double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(min(-1234.56, -3456.7), -3456.7);
+            TestUtils.AreEqual(min(-3456.7, -1234.56), -3456.7);
+            TestUtils.AreEqual(min(-1234.56, 3456.7), -1234.56);
+            TestUtils.AreEqual(min(3456.7, -1234.56), -1234.56);
+            TestUtils.AreEqual(min(1234.56, 3456.7), 1234.56);
+            TestUtils.AreEqual(min(3456.7, 1234.56), 1234.56);
+            TestUtils.AreEqual(min(1.0, double.PositiveInfinity), 1.0);
+            TestUtils.AreEqual(min(double.PositiveInfinity, 1.0), 1.0);
+            TestUtils.AreEqual(min(double.PositiveInfinity, double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(min(double.PositiveInfinity, double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(min(double.NaN, 2.3), 2.3);
+            TestUtils.AreEqual(min(2.3, double.NaN), 2.3);
+            TestUtils.AreEqual(min(double.NaN, double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void min_double2()
+        {
+            TestUtils.AreEqual(min(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)), double2(double.NegativeInfinity, double.NegativeInfinity));
+            TestUtils.AreEqual(min(double2(-1.0, -1234.56), double2(double.NegativeInfinity, -3456.7)), double2(double.NegativeInfinity, -3456.7));
+            TestUtils.AreEqual(min(double2(-3456.7, -1234.56), double2(-1234.56, 3456.7)), double2(-3456.7, -1234.56));
+            TestUtils.AreEqual(min(double2(3456.7, 1234.56), double2(-1234.56, 3456.7)), double2(-1234.56, 1234.56));
+            TestUtils.AreEqual(min(double2(3456.7, 1.0), double2(1234.56, double.PositiveInfinity)), double2(1234.56, 1.0));
+            TestUtils.AreEqual(min(double2(double.PositiveInfinity, double.PositiveInfinity), double2(1.0, double.NegativeInfinity)), double2(1.0, double.NegativeInfinity));
+            TestUtils.AreEqual(min(double2(double.PositiveInfinity, double.NaN), double2(double.PositiveInfinity, 2.3)), double2(double.PositiveInfinity, 2.3));
+            TestUtils.AreEqual(min(double2(2.3, double.NaN), double2(double.NaN, double.NaN)), double2(2.3, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void min_double3()
+        {
+            TestUtils.AreEqual(min(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity));
+            TestUtils.AreEqual(min(double3(-1234.56, -3456.7, -1234.56), double3(-3456.7, -1234.56, 3456.7)), double3(-3456.7, -3456.7, -1234.56));
+            TestUtils.AreEqual(min(double3(3456.7, 1234.56, 3456.7), double3(-1234.56, 3456.7, 1234.56)), double3(-1234.56, 1234.56, 1234.56));
+            TestUtils.AreEqual(min(double3(1.0, double.PositiveInfinity, double.PositiveInfinity), double3(double.PositiveInfinity, 1.0, double.NegativeInfinity)), double3(1.0, 1.0, double.NegativeInfinity));
+            TestUtils.AreEqual(min(double3(double.PositiveInfinity, double.NaN, 2.3), double3(double.PositiveInfinity, 2.3, double.NaN)), double3(double.PositiveInfinity, 2.3, 2.3));
+            TestUtils.AreEqual(min(double3(double.NaN, double.NaN, double.NaN), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void min_double4()
+        {
+            TestUtils.AreEqual(min(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -3456.7));
+            TestUtils.AreEqual(min(double4(-3456.7, -1234.56, 3456.7, 1234.56), double4(-1234.56, 3456.7, -1234.56, 3456.7)), double4(-3456.7, -1234.56, -1234.56, 1234.56));
+            TestUtils.AreEqual(min(double4(3456.7, 1.0, double.PositiveInfinity, double.PositiveInfinity), double4(1234.56, double.PositiveInfinity, 1.0, double.NegativeInfinity)), double4(1234.56, 1.0, 1.0, double.NegativeInfinity));
+            TestUtils.AreEqual(min(double4(double.PositiveInfinity, double.NaN, 2.3, double.NaN), double4(double.PositiveInfinity, 2.3, double.NaN, double.NaN)), double4(double.PositiveInfinity, 2.3, 2.3, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_int()
+        {
+            TestUtils.AreEqual(max(-2147483648, -2147483648), -2147483648);
+            TestUtils.AreEqual(max(-2147483648, -1), -1);
+            TestUtils.AreEqual(max(-1, -2147483648), -1);
+            TestUtils.AreEqual(max(-1234, -3456), -1234);
+            TestUtils.AreEqual(max(-3456, -1234), -1234);
+            TestUtils.AreEqual(max(-1234, 3456), 3456);
+            TestUtils.AreEqual(max(3456, -1234), 3456);
+            TestUtils.AreEqual(max(1234, 3456), 3456);
+            TestUtils.AreEqual(max(3456, 1234), 3456);
+            TestUtils.AreEqual(max(1, 2147483647), 2147483647);
+            TestUtils.AreEqual(max(2147483647, 1), 2147483647);
+            TestUtils.AreEqual(max(2147483647, -2147483648), 2147483647);
+            TestUtils.AreEqual(max(2147483647, 2147483647), 2147483647);
+        }
+
+        [TestCompiler]
+        public static void max_int2()
+        {
+            TestUtils.AreEqual(max(int2(-2147483648, -2147483648), int2(-2147483648, -1)), int2(-2147483648, -1));
+            TestUtils.AreEqual(max(int2(-1, -1234), int2(-2147483648, -3456)), int2(-1, -1234));
+            TestUtils.AreEqual(max(int2(-3456, -1234), int2(-1234, 3456)), int2(-1234, 3456));
+            TestUtils.AreEqual(max(int2(3456, 1234), int2(-1234, 3456)), int2(3456, 3456));
+            TestUtils.AreEqual(max(int2(3456, 1), int2(1234, 2147483647)), int2(3456, 2147483647));
+            TestUtils.AreEqual(max(int2(2147483647, 2147483647), int2(1, -2147483648)), int2(2147483647, 2147483647));
+            TestUtils.AreEqual(max(int2(2147483647, 2147483647), int2(2147483647, 2147483647)), int2(2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void max_int3()
+        {
+            TestUtils.AreEqual(max(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)), int3(-2147483648, -1, -1));
+            TestUtils.AreEqual(max(int3(-1234, -3456, -1234), int3(-3456, -1234, 3456)), int3(-1234, -1234, 3456));
+            TestUtils.AreEqual(max(int3(3456, 1234, 3456), int3(-1234, 3456, 1234)), int3(3456, 3456, 3456));
+            TestUtils.AreEqual(max(int3(1, 2147483647, 2147483647), int3(2147483647, 1, -2147483648)), int3(2147483647, 2147483647, 2147483647));
+            TestUtils.AreEqual(max(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)), int3(2147483647, 2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void max_int4()
+        {
+            TestUtils.AreEqual(max(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)), int4(-2147483648, -1, -1, -1234));
+            TestUtils.AreEqual(max(int4(-3456, -1234, 3456, 1234), int4(-1234, 3456, -1234, 3456)), int4(-1234, 3456, 3456, 3456));
+            TestUtils.AreEqual(max(int4(3456, 1, 2147483647, 2147483647), int4(1234, 2147483647, 1, -2147483648)), int4(3456, 2147483647, 2147483647, 2147483647));
+            TestUtils.AreEqual(max(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)), int4(2147483647, 2147483647, 2147483647, 2147483647));
+        }
+
+        [TestCompiler]
+        public static void max_uint()
+        {
+            TestUtils.AreEqual(max(1234u, 3456u), 3456u);
+            TestUtils.AreEqual(max(3456u, 1234u), 3456u);
+            TestUtils.AreEqual(max(4294967040u, 7u), 4294967040u);
+            TestUtils.AreEqual(max(7u, 4294967040u), 4294967040u);
+            TestUtils.AreEqual(max(1u, 4294967295u), 4294967295u);
+            TestUtils.AreEqual(max(4294967295u, 1u), 4294967295u);
+            TestUtils.AreEqual(max(4294967295u, 4294967295u), 4294967295u);
+        }
+
+        [TestCompiler]
+        public static void max_uint2()
+        {
+            TestUtils.AreEqual(max(uint2(1234u, 3456u), uint2(3456u, 1234u)), uint2(3456u, 3456u));
+            TestUtils.AreEqual(max(uint2(4294967040u, 7u), uint2(7u, 4294967040u)), uint2(4294967040u, 4294967040u));
+            TestUtils.AreEqual(max(uint2(1u, 4294967295u), uint2(4294967295u, 1u)), uint2(4294967295u, 4294967295u));
+            TestUtils.AreEqual(max(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)), uint2(4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void max_uint3()
+        {
+            TestUtils.AreEqual(max(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)), uint3(3456u, 3456u, 4294967040u));
+            TestUtils.AreEqual(max(uint3(7u, 1u, 4294967295u), uint3(4294967040u, 4294967295u, 1u)), uint3(4294967040u, 4294967295u, 4294967295u));
+            TestUtils.AreEqual(max(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)), uint3(4294967295u, 4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void max_uint4()
+        {
+            TestUtils.AreEqual(max(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)), uint4(3456u, 3456u, 4294967040u, 4294967040u));
+            TestUtils.AreEqual(max(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)), uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u));
+        }
+
+        [TestCompiler]
+        public static void max_long()
+        {
+            TestUtils.AreEqual(max(-9223372036854775808L, -9223372036854775808L), -9223372036854775808L);
+            TestUtils.AreEqual(max(-9223372036854775808L, -1L), -1L);
+            TestUtils.AreEqual(max(-1L, -9223372036854775808L), -1L);
+            TestUtils.AreEqual(max(-1234L, -3456L), -1234L);
+            TestUtils.AreEqual(max(-3456L, -1234L), -1234L);
+            TestUtils.AreEqual(max(-1234L, 3456L), 3456L);
+            TestUtils.AreEqual(max(3456L, -1234L), 3456L);
+            TestUtils.AreEqual(max(1234L, 3456L), 3456L);
+            TestUtils.AreEqual(max(3456L, 1234L), 3456L);
+            TestUtils.AreEqual(max(1L, 9223372036854775807L), 9223372036854775807L);
+            TestUtils.AreEqual(max(9223372036854775807L, 1L), 9223372036854775807L);
+            TestUtils.AreEqual(max(9223372036854775807L, -9223372036854775808L), 9223372036854775807L);
+            TestUtils.AreEqual(max(9223372036854775807L, 9223372036854775807L), 9223372036854775807L);
+        }
+
+        [TestCompiler]
+        public static void max_ulong()
+        {
+            TestUtils.AreEqual(max(1234UL, 3456UL), 3456UL);
+            TestUtils.AreEqual(max(3456UL, 1234UL), 3456UL);
+            TestUtils.AreEqual(max(18446744073709551360UL, 7UL), 18446744073709551360UL);
+            TestUtils.AreEqual(max(7UL, 18446744073709551360UL), 18446744073709551360UL);
+            TestUtils.AreEqual(max(1UL, 18446744073709551615UL), 18446744073709551615UL);
+            TestUtils.AreEqual(max(18446744073709551615UL, 1UL), 18446744073709551615UL);
+            TestUtils.AreEqual(max(18446744073709551615UL, 18446744073709551615UL), 18446744073709551615UL);
+        }
+
+        [TestCompiler]
+        public static void max_float()
+        {
+            TestUtils.AreEqual(max(float.NegativeInfinity, float.NegativeInfinity), float.NegativeInfinity);
+            TestUtils.AreEqual(max(float.NegativeInfinity, -1f), -1f);
+            TestUtils.AreEqual(max(-1f, float.NegativeInfinity), -1f);
+            TestUtils.AreEqual(max(-1234.56f, -3456.7f), -1234.56f);
+            TestUtils.AreEqual(max(-3456.7f, -1234.56f), -1234.56f);
+            TestUtils.AreEqual(max(-1234.56f, 3456.7f), 3456.7f);
+            TestUtils.AreEqual(max(3456.7f, -1234.56f), 3456.7f);
+            TestUtils.AreEqual(max(1234.56f, 3456.7f), 3456.7f);
+            TestUtils.AreEqual(max(3456.7f, 1234.56f), 3456.7f);
+            TestUtils.AreEqual(max(1f, float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(max(float.PositiveInfinity, 1f), float.PositiveInfinity);
+            TestUtils.AreEqual(max(float.PositiveInfinity, float.NegativeInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(max(float.PositiveInfinity, float.PositiveInfinity), float.PositiveInfinity);
+            TestUtils.AreEqual(max(float.NaN, 2.3f), 2.3f);
+            TestUtils.AreEqual(max(2.3f, float.NaN), 2.3f);
+            TestUtils.AreEqual(max(float.NaN, float.NaN), float.NaN);
+        }
+
+        [TestCompiler]
+        public static void max_float2()
+        {
+            TestUtils.AreEqual(max(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)), float2(float.NegativeInfinity, -1f));
+            TestUtils.AreEqual(max(float2(-1f, -1234.56f), float2(float.NegativeInfinity, -3456.7f)), float2(-1f, -1234.56f));
+            TestUtils.AreEqual(max(float2(-3456.7f, -1234.56f), float2(-1234.56f, 3456.7f)), float2(-1234.56f, 3456.7f));
+            TestUtils.AreEqual(max(float2(3456.7f, 1234.56f), float2(-1234.56f, 3456.7f)), float2(3456.7f, 3456.7f));
+            TestUtils.AreEqual(max(float2(3456.7f, 1f), float2(1234.56f, float.PositiveInfinity)), float2(3456.7f, float.PositiveInfinity));
+            TestUtils.AreEqual(max(float2(float.PositiveInfinity, float.PositiveInfinity), float2(1f, float.NegativeInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity));
+            TestUtils.AreEqual(max(float2(float.PositiveInfinity, float.NaN), float2(float.PositiveInfinity, 2.3f)), float2(float.PositiveInfinity, 2.3f));
+            TestUtils.AreEqual(max(float2(2.3f, float.NaN), float2(float.NaN, float.NaN)), float2(2.3f, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_float3()
+        {
+            TestUtils.AreEqual(max(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)), float3(float.NegativeInfinity, -1f, -1f));
+            TestUtils.AreEqual(max(float3(-1234.56f, -3456.7f, -1234.56f), float3(-3456.7f, -1234.56f, 3456.7f)), float3(-1234.56f, -1234.56f, 3456.7f));
+            TestUtils.AreEqual(max(float3(3456.7f, 1234.56f, 3456.7f), float3(-1234.56f, 3456.7f, 1234.56f)), float3(3456.7f, 3456.7f, 3456.7f));
+            TestUtils.AreEqual(max(float3(1f, float.PositiveInfinity, float.PositiveInfinity), float3(float.PositiveInfinity, 1f, float.NegativeInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity));
+            TestUtils.AreEqual(max(float3(float.PositiveInfinity, float.NaN, 2.3f), float3(float.PositiveInfinity, 2.3f, float.NaN)), float3(float.PositiveInfinity, 2.3f, 2.3f));
+            TestUtils.AreEqual(max(float3(float.NaN, float.NaN, float.NaN), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_float4()
+        {
+            TestUtils.AreEqual(max(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)), float4(float.NegativeInfinity, -1f, -1f, -1234.56f));
+            TestUtils.AreEqual(max(float4(-3456.7f, -1234.56f, 3456.7f, 1234.56f), float4(-1234.56f, 3456.7f, -1234.56f, 3456.7f)), float4(-1234.56f, 3456.7f, 3456.7f, 3456.7f));
+            TestUtils.AreEqual(max(float4(3456.7f, 1f, float.PositiveInfinity, float.PositiveInfinity), float4(1234.56f, float.PositiveInfinity, 1f, float.NegativeInfinity)), float4(3456.7f, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity));
+            TestUtils.AreEqual(max(float4(float.PositiveInfinity, float.NaN, 2.3f, float.NaN), float4(float.PositiveInfinity, 2.3f, float.NaN, float.NaN)), float4(float.PositiveInfinity, 2.3f, 2.3f, float.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_double()
+        {
+            TestUtils.AreEqual(max(double.NegativeInfinity, double.NegativeInfinity), double.NegativeInfinity);
+            TestUtils.AreEqual(max(double.NegativeInfinity, -1.0), -1.0);
+            TestUtils.AreEqual(max(-1.0, double.NegativeInfinity), -1.0);
+            TestUtils.AreEqual(max(-1234.56, -3456.7), -1234.56);
+            TestUtils.AreEqual(max(-3456.7, -1234.56), -1234.56);
+            TestUtils.AreEqual(max(-1234.56, 3456.7), 3456.7);
+            TestUtils.AreEqual(max(3456.7, -1234.56), 3456.7);
+            TestUtils.AreEqual(max(1234.56, 3456.7), 3456.7);
+            TestUtils.AreEqual(max(3456.7, 1234.56), 3456.7);
+            TestUtils.AreEqual(max(1.0, double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(max(double.PositiveInfinity, 1.0), double.PositiveInfinity);
+            TestUtils.AreEqual(max(double.PositiveInfinity, double.NegativeInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(max(double.PositiveInfinity, double.PositiveInfinity), double.PositiveInfinity);
+            TestUtils.AreEqual(max(double.NaN, 2.3), 2.3);
+            TestUtils.AreEqual(max(2.3, double.NaN), 2.3);
+            TestUtils.AreEqual(max(double.NaN, double.NaN), double.NaN);
+        }
+
+        [TestCompiler]
+        public static void max_double2()
+        {
+            TestUtils.AreEqual(max(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)), double2(double.NegativeInfinity, -1.0));
+            TestUtils.AreEqual(max(double2(-1.0, -1234.56), double2(double.NegativeInfinity, -3456.7)), double2(-1.0, -1234.56));
+            TestUtils.AreEqual(max(double2(-3456.7, -1234.56), double2(-1234.56, 3456.7)), double2(-1234.56, 3456.7));
+            TestUtils.AreEqual(max(double2(3456.7, 1234.56), double2(-1234.56, 3456.7)), double2(3456.7, 3456.7));
+            TestUtils.AreEqual(max(double2(3456.7, 1.0), double2(1234.56, double.PositiveInfinity)), double2(3456.7, double.PositiveInfinity));
+            TestUtils.AreEqual(max(double2(double.PositiveInfinity, double.PositiveInfinity), double2(1.0, double.NegativeInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity));
+            TestUtils.AreEqual(max(double2(double.PositiveInfinity, double.NaN), double2(double.PositiveInfinity, 2.3)), double2(double.PositiveInfinity, 2.3));
+            TestUtils.AreEqual(max(double2(2.3, double.NaN), double2(double.NaN, double.NaN)), double2(2.3, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_double3()
+        {
+            TestUtils.AreEqual(max(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)), double3(double.NegativeInfinity, -1.0, -1.0));
+            TestUtils.AreEqual(max(double3(-1234.56, -3456.7, -1234.56), double3(-3456.7, -1234.56, 3456.7)), double3(-1234.56, -1234.56, 3456.7));
+            TestUtils.AreEqual(max(double3(3456.7, 1234.56, 3456.7), double3(-1234.56, 3456.7, 1234.56)), double3(3456.7, 3456.7, 3456.7));
+            TestUtils.AreEqual(max(double3(1.0, double.PositiveInfinity, double.PositiveInfinity), double3(double.PositiveInfinity, 1.0, double.NegativeInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity));
+            TestUtils.AreEqual(max(double3(double.PositiveInfinity, double.NaN, 2.3), double3(double.PositiveInfinity, 2.3, double.NaN)), double3(double.PositiveInfinity, 2.3, 2.3));
+            TestUtils.AreEqual(max(double3(double.NaN, double.NaN, double.NaN), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void max_double4()
+        {
+            TestUtils.AreEqual(max(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)), double4(double.NegativeInfinity, -1.0, -1.0, -1234.56));
+            TestUtils.AreEqual(max(double4(-3456.7, -1234.56, 3456.7, 1234.56), double4(-1234.56, 3456.7, -1234.56, 3456.7)), double4(-1234.56, 3456.7, 3456.7, 3456.7));
+            TestUtils.AreEqual(max(double4(3456.7, 1.0, double.PositiveInfinity, double.PositiveInfinity), double4(1234.56, double.PositiveInfinity, 1.0, double.NegativeInfinity)), double4(3456.7, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity));
+            TestUtils.AreEqual(max(double4(double.PositiveInfinity, double.NaN, 2.3, double.NaN), double4(double.PositiveInfinity, 2.3, double.NaN, double.NaN)), double4(double.PositiveInfinity, 2.3, 2.3, double.NaN));
+        }
+
+        [TestCompiler]
+        public static void smoothstep_float()
+        {
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, float.NegativeInfinity), 0f, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, -200f), 0f, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, -100f), 0.00724848127f, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, 400f), 1f, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, float.PositiveInfinity), 1f, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45f, 345.6f, float.NaN), 1f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, float.NegativeInfinity), 1f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, -200f), 1f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, -100f), 0.992751539f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, 400f), 0f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, float.PositiveInfinity), 0f, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6f, -123.45f, float.NaN), 1f, 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_float2()
+        {
+            TestUtils.AreEqual(smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.NegativeInfinity, -200f)), float2(0f, 0f), 8, false);
+            TestUtils.AreEqual(smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(-100f, 400f)), float2(0.00724848127f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.PositiveInfinity, float.NaN)), float2(1f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f)), float2(1f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(-100f, 400f)), float2(0.992751539f, 0f), 8, false);
+            TestUtils.AreEqual(smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.PositiveInfinity, float.NaN)), float2(0f, 1f), 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_float3()
+        {
+            TestUtils.AreEqual(smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NegativeInfinity, -200f, -100f)), float3(0f, 0f, 0.00724848127f), 8, false);
+            TestUtils.AreEqual(smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(400f, float.PositiveInfinity, float.NaN)), float3(1f, 1f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, -100f)), float3(1f, 1f, 0.992751539f), 8, false);
+            TestUtils.AreEqual(smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(400f, float.PositiveInfinity, float.NaN)), float3(0f, 0f, 1f), 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_float4()
+        {
+            TestUtils.AreEqual(smoothstep(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(345.6f, 345.6f, 345.6f, 345.6f), float4(float.NegativeInfinity, -200f, -100f, 400f)), float4(0f, 0f, 0.00724848127f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float4(-123.45f, -123.45f, 345.6f, 345.6f), float4(345.6f, 345.6f, -123.45f, -123.45f), float4(float.PositiveInfinity, float.NaN, float.NegativeInfinity, -200f)), float4(1f, 1f, 1f, 1f), 8, false);
+            TestUtils.AreEqual(smoothstep(float4(345.6f, 345.6f, 345.6f, 345.6f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(-100f, 400f, float.PositiveInfinity, float.NaN)), float4(0.992751539f, 0f, 0f, 1f), 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_double()
+        {
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, double.NegativeInfinity), 0.0, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, -200.0), 0.0, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, -100.0), 0.0072484810488798995, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, 400.0), 1.0, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, double.PositiveInfinity), 1.0, 8, false);
+            TestUtils.AreEqual(smoothstep(-123.45, 345.6, double.NaN), 1.0, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, double.NegativeInfinity), 1.0, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, -200.0), 1.0, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, -100.0), 0.99275151895112013, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, 400.0), 0.0, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, double.PositiveInfinity), 0.0, 8, false);
+            TestUtils.AreEqual(smoothstep(345.6, -123.45, double.NaN), 1.0, 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_double2()
+        {
+            TestUtils.AreEqual(smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.NegativeInfinity, -200.0)), double2(0.0, 0.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(-100.0, 400.0)), double2(0.0072484810488798995, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.PositiveInfinity, double.NaN)), double2(1.0, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0)), double2(1.0, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(-100.0, 400.0)), double2(0.99275151895112013, 0.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.PositiveInfinity, double.NaN)), double2(0.0, 1.0), 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_double3()
+        {
+            TestUtils.AreEqual(smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NegativeInfinity, -200.0, -100.0)), double3(0.0, 0.0, 0.0072484810488798995), 8, false);
+            TestUtils.AreEqual(smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(400.0, double.PositiveInfinity, double.NaN)), double3(1.0, 1.0, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, -100.0)), double3(1.0, 1.0, 0.99275151895112013), 8, false);
+            TestUtils.AreEqual(smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(400.0, double.PositiveInfinity, double.NaN)), double3(0.0, 0.0, 1.0), 8, false);
+        }
+
+        [TestCompiler]
+        public static void smoothstep_double4()
+        {
+            TestUtils.AreEqual(smoothstep(double4(-123.45, -123.45, -123.45, -123.45), double4(345.6, 345.6, 345.6, 345.6), double4(double.NegativeInfinity, -200.0, -100.0, 400.0)), double4(0.0, 0.0, 0.0072484810488798995, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double4(-123.45, -123.45, 345.6, 345.6), double4(345.6, 345.6, -123.45, -123.45), double4(double.PositiveInfinity, double.NaN, double.NegativeInfinity, -200.0)), double4(1.0, 1.0, 1.0, 1.0), 8, false);
+            TestUtils.AreEqual(smoothstep(double4(345.6, 345.6, 345.6, 345.6), double4(-123.45, -123.45, -123.45, -123.45), double4(-100.0, 400.0, double.PositiveInfinity, double.NaN)), double4(0.99275151895112013, 0.0, 0.0, 1.0), 8, false);
+        }
+
+        [TestCompiler]
+        public static void mad_int()
+        {
+            TestUtils.AreEqual(mad(1234, 5678, 91011), 7097663);
+            TestUtils.AreEqual(mad(1234, 5678, -91011), 6915641);
+            TestUtils.AreEqual(mad(1234, -5678, 91011), -6915641);
+            TestUtils.AreEqual(mad(1234, -5678, -91011), -7097663);
+            TestUtils.AreEqual(mad(-1234, 5678, 91011), -6915641);
+            TestUtils.AreEqual(mad(-1234, 5678, -91011), -7097663);
+            TestUtils.AreEqual(mad(-1234, -5678, 91011), 7097663);
+            TestUtils.AreEqual(mad(-1234, -5678, -91011), 6915641);
+            TestUtils.AreEqual(mad(98765, 56789, 91011), 1313889300);
+            TestUtils.AreEqual(mad(98765, 56789, -91011), 1313707278);
+            TestUtils.AreEqual(mad(98765, -56789, 91011), -1313707278);
+            TestUtils.AreEqual(mad(98765, -56789, -91011), -1313889300);
+            TestUtils.AreEqual(mad(-98765, 56789, 91011), -1313707278);
+            TestUtils.AreEqual(mad(-98765, 56789, -91011), -1313889300);
+            TestUtils.AreEqual(mad(-98765, -56789, 91011), 1313889300);
+            TestUtils.AreEqual(mad(-98765, -56789, -91011), 1313707278);
+        }
+
+        [TestCompiler]
+        public static void mad_int2()
+        {
+            TestUtils.AreEqual(mad(int2(1234, 1234), int2(5678, 5678), int2(91011, -91011)), int2(7097663, 6915641));
+            TestUtils.AreEqual(mad(int2(1234, 1234), int2(-5678, -5678), int2(91011, -91011)), int2(-6915641, -7097663));
+            TestUtils.AreEqual(mad(int2(-1234, -1234), int2(5678, 5678), int2(91011, -91011)), int2(-6915641, -7097663));
+            TestUtils.AreEqual(mad(int2(-1234, -1234), int2(-5678, -5678), int2(91011, -91011)), int2(7097663, 6915641));
+            TestUtils.AreEqual(mad(int2(98765, 98765), int2(56789, 56789), int2(91011, -91011)), int2(1313889300, 1313707278));
+            TestUtils.AreEqual(mad(int2(98765, 98765), int2(-56789, -56789), int2(91011, -91011)), int2(-1313707278, -1313889300));
+            TestUtils.AreEqual(mad(int2(-98765, -98765), int2(56789, 56789), int2(91011, -91011)), int2(-1313707278, -1313889300));
+            TestUtils.AreEqual(mad(int2(-98765, -98765), int2(-56789, -56789), int2(91011, -91011)), int2(1313889300, 1313707278));
+        }
+
+        [TestCompiler]
+        public static void mad_int3()
+        {
+            TestUtils.AreEqual(mad(int3(1234, 1234, 1234), int3(5678, 5678, -5678), int3(91011, -91011, 91011)), int3(7097663, 6915641, -6915641));
+            TestUtils.AreEqual(mad(int3(1234, -1234, -1234), int3(-5678, 5678, 5678), int3(-91011, 91011, -91011)), int3(-7097663, -6915641, -7097663));
+            TestUtils.AreEqual(mad(int3(-1234, -1234, 98765), int3(-5678, -5678, 56789), int3(91011, -91011, 91011)), int3(7097663, 6915641, 1313889300));
+            TestUtils.AreEqual(mad(int3(98765, 98765, 98765), int3(56789, -56789, -56789), int3(-91011, 91011, -91011)), int3(1313707278, -1313707278, -1313889300));
+            TestUtils.AreEqual(mad(int3(-98765, -98765, -98765), int3(56789, 56789, -56789), int3(91011, -91011, 91011)), int3(-1313707278, -1313889300, 1313889300));
+            TestUtils.AreEqual(mad(int3(-98765, -98765, -98765), int3(-56789, -56789, -56789), int3(-91011, -91011, -91011)), int3(1313707278, 1313707278, 1313707278));
+        }
+
+        [TestCompiler]
+        public static void mad_int4()
+        {
+            TestUtils.AreEqual(mad(int4(1234, 1234, 1234, 1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011)), int4(7097663, 6915641, -6915641, -7097663));
+            TestUtils.AreEqual(mad(int4(-1234, -1234, -1234, -1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011)), int4(-6915641, -7097663, 7097663, 6915641));
+            TestUtils.AreEqual(mad(int4(98765, 98765, 98765, 98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011)), int4(1313889300, 1313707278, -1313707278, -1313889300));
+            TestUtils.AreEqual(mad(int4(-98765, -98765, -98765, -98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011)), int4(-1313707278, -1313889300, 1313889300, 1313707278));
+        }
+
+        [TestCompiler]
+        public static void mad_uint()
+        {
+            TestUtils.AreEqual(mad(1234u, 5678u, 91011u), 7097663u);
+            TestUtils.AreEqual(mad(98765u, 56789u, 91011u), 1313889300u);
+        }
+
+        [TestCompiler]
+        public static void mad_uint2()
+        {
+            TestUtils.AreEqual(mad(uint2(1234u, 98765u), uint2(5678u, 56789u), uint2(91011u, 91011u)), uint2(7097663u, 1313889300u));
+        }
+
+        [TestCompiler]
+        public static void mad_uint3()
+        {
+            TestUtils.AreEqual(mad(uint3(1234u, 98765u, 98765u), uint3(5678u, 56789u, 56789u), uint3(91011u, 91011u, 91011u)), uint3(7097663u, 1313889300u, 1313889300u));
+        }
+
+        [TestCompiler]
+        public static void mad_uint4()
+        {
+            TestUtils.AreEqual(mad(uint4(1234u, 98765u, 98765u, 98765u), uint4(5678u, 56789u, 56789u, 56789u), uint4(91011u, 91011u, 91011u, 91011u)), uint4(7097663u, 1313889300u, 1313889300u, 1313889300u));
+        }
+
+        [TestCompiler]
+        public static void mad_long()
+        {
+            TestUtils.AreEqual(mad(1234L, 5678L, 91011L), 7097663L);
+            TestUtils.AreEqual(mad(1234L, 5678L, -91011L), 6915641L);
+            TestUtils.AreEqual(mad(1234L, -5678L, 91011L), -6915641L);
+            TestUtils.AreEqual(mad(1234L, -5678L, -91011L), -7097663L);
+            TestUtils.AreEqual(mad(-1234L, 5678L, 91011L), -6915641L);
+            TestUtils.AreEqual(mad(-1234L, 5678L, -91011L), -7097663L);
+            TestUtils.AreEqual(mad(-1234L, -5678L, 91011L), 7097663L);
+            TestUtils.AreEqual(mad(-1234L, -5678L, -91011L), 6915641L);
+            TestUtils.AreEqual(mad(9876543210L, 5678901234L, 9101112134L), 747681210895778426L);
+            TestUtils.AreEqual(mad(9876543210L, 5678901234L, -9101112134L), 747681192693554158L);
+            TestUtils.AreEqual(mad(9876543210L, -5678901234L, 9101112134L), -747681192693554158L);
+            TestUtils.AreEqual(mad(9876543210L, -5678901234L, -9101112134L), -747681210895778426L);
+            TestUtils.AreEqual(mad(-9876543210L, 5678901234L, 9101112134L), -747681192693554158L);
+            TestUtils.AreEqual(mad(-9876543210L, 5678901234L, -9101112134L), -747681210895778426L);
+            TestUtils.AreEqual(mad(-9876543210L, -5678901234L, 9101112134L), 747681210895778426L);
+            TestUtils.AreEqual(mad(-9876543210L, -5678901234L, -9101112134L), 747681192693554158L);
+        }
+
+        [TestCompiler]
+        public static void mad_ulong()
+        {
+            TestUtils.AreEqual(mad(1234UL, 5678UL, 91011UL), 7097663L);
+            TestUtils.AreEqual(mad(9876543210UL, 5678901234UL, 9101112134UL), 747681210895778426L);
+        }
+
+        [TestCompiler]
+        public static void mad_float()
+        {
+            TestUtils.AreEqual(mad(-123.45f, 345.6f, 4.321f), -42660f, 1, false);
+            TestUtils.AreEqual(mad(float.NaN, 345.6f, 4.321f), float.NaN, 1, false);
+            TestUtils.AreEqual(mad(-123.45f, float.NaN, 4.321f), float.NaN, 1, false);
+            TestUtils.AreEqual(mad(-123.45f, 345.6f, float.NaN), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_float2()
+        {
+            TestUtils.AreEqual(mad(float2(-123.45f, float.NaN), float2(345.6f, 345.6f), float2(4.321f, 4.321f)), float2(-42660f, float.NaN), 1, false);
+            TestUtils.AreEqual(mad(float2(-123.45f, -123.45f), float2(float.NaN, 345.6f), float2(4.321f, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_float3()
+        {
+            TestUtils.AreEqual(mad(float3(-123.45f, float.NaN, -123.45f), float3(345.6f, 345.6f, float.NaN), float3(4.321f, 4.321f, 4.321f)), float3(-42660f, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(mad(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_float4()
+        {
+            TestUtils.AreEqual(mad(float4(-123.45f, float.NaN, -123.45f, -123.45f), float4(345.6f, 345.6f, float.NaN, 345.6f), float4(4.321f, 4.321f, 4.321f, float.NaN)), float4(-42660f, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_double()
+        {
+            TestUtils.AreEqual(mad(-123.45, 345.6, 4.321), -42659.999, 1, false);
+            TestUtils.AreEqual(mad(double.NaN, 345.6, 4.321), double.NaN, 1, false);
+            TestUtils.AreEqual(mad(-123.45, double.NaN, 4.321), double.NaN, 1, false);
+            TestUtils.AreEqual(mad(-123.45, 345.6, double.NaN), double.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_double2()
+        {
+            TestUtils.AreEqual(mad(double2(-123.45, double.NaN), double2(345.6, 345.6), double2(4.321, 4.321)), double2(-42659.999, double.NaN), 1, false);
+            TestUtils.AreEqual(mad(double2(-123.45, -123.45), double2(double.NaN, 345.6), double2(4.321, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_double3()
+        {
+            TestUtils.AreEqual(mad(double3(-123.45, double.NaN, -123.45), double3(345.6, 345.6, double.NaN), double3(4.321, 4.321, 4.321)), double3(-42659.999, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(mad(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void mad_double4()
+        {
+            TestUtils.AreEqual(mad(double4(-123.45, double.NaN, -123.45, -123.45), double4(345.6, 345.6, double.NaN, 345.6), double4(4.321, 4.321, 4.321, double.NaN)), double4(-42659.999, double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_float()
+        {
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, float.NegativeInfinity), -323.4f, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, float.NegativeInfinity), -0.0f, 1, false);
+            TestUtils.AreEqual(fmod(0f, float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, float.NegativeInfinity), 323.4f, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, -123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, -123.6f), -76.2f, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, -123.6f), -0.0f, 1, false);
+            TestUtils.AreEqual(fmod(0f, -123.6f), 0f, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, -123.6f), 76.2f, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, -123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, -123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0f, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, -0.0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0f, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, 0f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, 123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, 123.6f), -76.2f, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, 123.6f), -0.0f, 1, false);
+            TestUtils.AreEqual(fmod(0f, 123.6f), 0f, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, 123.6f), 76.2f, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, 123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, 123.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, float.PositiveInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, float.PositiveInfinity), -323.4f, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, float.PositiveInfinity), -0.0f, 1, false);
+            TestUtils.AreEqual(fmod(0f, float.PositiveInfinity), 0f, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, float.PositiveInfinity), 323.4f, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, float.PositiveInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, float.PositiveInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NegativeInfinity, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.PositiveInfinity, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(fmod(float.NaN, float.NaN), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_float2()
+        {
+            TestUtils.AreEqual(fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(float.NaN, -323.4f), 1, false);
+            TestUtils.AreEqual(fmod(float2(-0.0f, 0f), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(-0.0f, 0f), 1, false);
+            TestUtils.AreEqual(fmod(float2(323.4f, float.PositiveInfinity), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(323.4f, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NaN, float.NegativeInfinity), float2(float.NegativeInfinity, -123.6f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(-323.4f, -0.0f), float2(-123.6f, -123.6f)), float2(-76.2f, -0.0f), 1, false);
+            TestUtils.AreEqual(fmod(float2(0f, 323.4f), float2(-123.6f, -123.6f)), float2(0f, 76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.PositiveInfinity, float.NaN), float2(-123.6f, -123.6f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NegativeInfinity, -323.4f), float2(-0.0f, -0.0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(-0.0f, 0f), float2(-0.0f, -0.0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(323.4f, float.PositiveInfinity), float2(-0.0f, -0.0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NaN, float.NegativeInfinity), float2(-0.0f, 0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(-323.4f, -0.0f), float2(0f, 0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(0f, 323.4f), float2(0f, 0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.PositiveInfinity, float.NaN), float2(0f, 0f)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NegativeInfinity, -323.4f), float2(123.6f, 123.6f)), float2(float.NaN, -76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float2(-0.0f, 0f), float2(123.6f, 123.6f)), float2(-0.0f, 0f), 1, false);
+            TestUtils.AreEqual(fmod(float2(323.4f, float.PositiveInfinity), float2(123.6f, 123.6f)), float2(76.2f, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NaN, float.NegativeInfinity), float2(123.6f, float.PositiveInfinity)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(-323.4f, -0.0f), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(-323.4f, -0.0f), 1, false);
+            TestUtils.AreEqual(fmod(float2(0f, 323.4f), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(0f, 323.4f), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.PositiveInfinity, float.NaN), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(-0.0f, 0f), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(323.4f, float.PositiveInfinity), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float2(float.NaN, float.NaN), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_float3()
+        {
+            TestUtils.AreEqual(fmod(float3(float.NegativeInfinity, -323.4f, -0.0f), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float3(float.NaN, -323.4f, -0.0f), 1, false);
+            TestUtils.AreEqual(fmod(float3(0f, 323.4f, float.PositiveInfinity), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float3(0f, 323.4f, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.NaN, float.NegativeInfinity, -323.4f), float3(float.NegativeInfinity, -123.6f, -123.6f)), float3(float.NaN, float.NaN, -76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float3(-0.0f, 0f, 323.4f), float3(-123.6f, -123.6f, -123.6f)), float3(-0.0f, 0f, 76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.PositiveInfinity, float.NaN, float.NegativeInfinity), float3(-123.6f, -123.6f, -0.0f)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(-323.4f, -0.0f, 0f), float3(-0.0f, -0.0f, -0.0f)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(323.4f, float.PositiveInfinity, float.NaN), float3(-0.0f, -0.0f, -0.0f)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.NegativeInfinity, -323.4f, -0.0f), float3(0f, 0f, 0f)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(0f, 323.4f, float.PositiveInfinity), float3(0f, 0f, 0f)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.NaN, float.NegativeInfinity, -323.4f), float3(0f, 123.6f, 123.6f)), float3(float.NaN, float.NaN, -76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float3(-0.0f, 0f, 323.4f), float3(123.6f, 123.6f, 123.6f)), float3(-0.0f, 0f, 76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.PositiveInfinity, float.NaN, float.NegativeInfinity), float3(123.6f, 123.6f, float.PositiveInfinity)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(-323.4f, -0.0f, 0f), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(-323.4f, -0.0f, 0f), 1, false);
+            TestUtils.AreEqual(fmod(float3(323.4f, float.PositiveInfinity, float.NaN), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(323.4f, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.NegativeInfinity, -323.4f, -0.0f), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(0f, 323.4f, float.PositiveInfinity), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float3(float.NaN, float.NaN, float.NaN), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_float4()
+        {
+            TestUtils.AreEqual(fmod(float4(float.NegativeInfinity, -323.4f, -0.0f, 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float4(float.NaN, -323.4f, -0.0f, 0f), 1, false);
+            TestUtils.AreEqual(fmod(float4(323.4f, float.PositiveInfinity, float.NaN, float.NegativeInfinity), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -123.6f)), float4(323.4f, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(-323.4f, -0.0f, 0f, 323.4f), float4(-123.6f, -123.6f, -123.6f, -123.6f)), float4(-76.2f, -0.0f, 0f, 76.2f), 1, false);
+            TestUtils.AreEqual(fmod(float4(float.PositiveInfinity, float.NaN, float.NegativeInfinity, -323.4f), float4(-123.6f, -123.6f, -0.0f, -0.0f)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(-0.0f, 0f, 323.4f, float.PositiveInfinity), float4(-0.0f, -0.0f, -0.0f, -0.0f)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(float.NaN, float.NegativeInfinity, -323.4f, -0.0f), float4(-0.0f, 0f, 0f, 0f)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(0f, 323.4f, float.PositiveInfinity, float.NaN), float4(0f, 0f, 0f, 0f)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(float.NegativeInfinity, -323.4f, -0.0f, 0f), float4(123.6f, 123.6f, 123.6f, 123.6f)), float4(float.NaN, -76.2f, -0.0f, 0f), 1, false);
+            TestUtils.AreEqual(fmod(float4(323.4f, float.PositiveInfinity, float.NaN, float.NegativeInfinity), float4(123.6f, 123.6f, 123.6f, float.PositiveInfinity)), float4(76.2f, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(-323.4f, -0.0f, 0f, 323.4f), float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(-323.4f, -0.0f, 0f, 323.4f), 1, false);
+            TestUtils.AreEqual(fmod(float4(float.PositiveInfinity, float.NaN, float.NegativeInfinity, -323.4f), float4(float.PositiveInfinity, float.PositiveInfinity, float.NaN, float.NaN)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(-0.0f, 0f, 323.4f, float.PositiveInfinity), float4(float.NaN, float.NaN, float.NaN, float.NaN)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(fmod(float4(float.NaN, float.NaN, float.NaN, float.NaN), float4(float.NaN, float.NaN, float.NaN, float.NaN)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_double()
+        {
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, double.NegativeInfinity), -323.4, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, double.NegativeInfinity), -0.0, 1, false);
+            TestUtils.AreEqual(fmod(0.0, double.NegativeInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(fmod(323.4, double.NegativeInfinity), 323.4, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, -123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, -123.6), -76.2, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, -123.6), -0.0, 1, false);
+            TestUtils.AreEqual(fmod(0.0, -123.6), 0.0, 1, false);
+            TestUtils.AreEqual(fmod(323.4, -123.6), 76.2, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, -123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, -123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0.0, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, -0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0.0, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, 0.0), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, 123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, 123.6), -76.2, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, 123.6), -0.0, 1, false);
+            TestUtils.AreEqual(fmod(0.0, 123.6), 0.0, 1, false);
+            TestUtils.AreEqual(fmod(323.4, 123.6), 76.2, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, 123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, 123.6), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, double.PositiveInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, double.PositiveInfinity), -323.4, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, double.PositiveInfinity), -0.0, 1, false);
+            TestUtils.AreEqual(fmod(0.0, double.PositiveInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(fmod(323.4, double.PositiveInfinity), 323.4, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, double.PositiveInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, double.PositiveInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NegativeInfinity, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-323.4, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(-0.0, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(0.0, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(323.4, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.PositiveInfinity, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(fmod(double.NaN, double.NaN), double.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_double2()
+        {
+            TestUtils.AreEqual(fmod(double2(double.NegativeInfinity, -323.4), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(double.NaN, -323.4), 1, false);
+            TestUtils.AreEqual(fmod(double2(-0.0, 0.0), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(-0.0, 0.0), 1, false);
+            TestUtils.AreEqual(fmod(double2(323.4, double.PositiveInfinity), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(323.4, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NaN, double.NegativeInfinity), double2(double.NegativeInfinity, -123.6)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(-323.4, -0.0), double2(-123.6, -123.6)), double2(-76.2, -0.0), 1, false);
+            TestUtils.AreEqual(fmod(double2(0.0, 323.4), double2(-123.6, -123.6)), double2(0.0, 76.2), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.PositiveInfinity, double.NaN), double2(-123.6, -123.6)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NegativeInfinity, -323.4), double2(-0.0, -0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(-0.0, 0.0), double2(-0.0, -0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(323.4, double.PositiveInfinity), double2(-0.0, -0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NaN, double.NegativeInfinity), double2(-0.0, 0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(-323.4, -0.0), double2(0.0, 0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(0.0, 323.4), double2(0.0, 0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.PositiveInfinity, double.NaN), double2(0.0, 0.0)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NegativeInfinity, -323.4), double2(123.6, 123.6)), double2(double.NaN, -76.2), 1, false);
+            TestUtils.AreEqual(fmod(double2(-0.0, 0.0), double2(123.6, 123.6)), double2(-0.0, 0.0), 1, false);
+            TestUtils.AreEqual(fmod(double2(323.4, double.PositiveInfinity), double2(123.6, 123.6)), double2(76.2, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NaN, double.NegativeInfinity), double2(123.6, double.PositiveInfinity)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(-323.4, -0.0), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(-323.4, -0.0), 1, false);
+            TestUtils.AreEqual(fmod(double2(0.0, 323.4), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(0.0, 323.4), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.PositiveInfinity, double.NaN), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NegativeInfinity, -323.4), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(-0.0, 0.0), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(323.4, double.PositiveInfinity), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double2(double.NaN, double.NaN), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_double3()
+        {
+            TestUtils.AreEqual(fmod(double3(double.NegativeInfinity, -323.4, -0.0), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double3(double.NaN, -323.4, -0.0), 1, false);
+            TestUtils.AreEqual(fmod(double3(0.0, 323.4, double.PositiveInfinity), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double3(0.0, 323.4, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.NaN, double.NegativeInfinity, -323.4), double3(double.NegativeInfinity, -123.6, -123.6)), double3(double.NaN, double.NaN, -76.2), 1, false);
+            TestUtils.AreEqual(fmod(double3(-0.0, 0.0, 323.4), double3(-123.6, -123.6, -123.6)), double3(-0.0, 0.0, 76.2), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.PositiveInfinity, double.NaN, double.NegativeInfinity), double3(-123.6, -123.6, -0.0)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(-323.4, -0.0, 0.0), double3(-0.0, -0.0, -0.0)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(323.4, double.PositiveInfinity, double.NaN), double3(-0.0, -0.0, -0.0)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.NegativeInfinity, -323.4, -0.0), double3(0.0, 0.0, 0.0)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(0.0, 323.4, double.PositiveInfinity), double3(0.0, 0.0, 0.0)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.NaN, double.NegativeInfinity, -323.4), double3(0.0, 123.6, 123.6)), double3(double.NaN, double.NaN, -76.2), 1, false);
+            TestUtils.AreEqual(fmod(double3(-0.0, 0.0, 323.4), double3(123.6, 123.6, 123.6)), double3(-0.0, 0.0, 76.2), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.PositiveInfinity, double.NaN, double.NegativeInfinity), double3(123.6, 123.6, double.PositiveInfinity)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(-323.4, -0.0, 0.0), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(-323.4, -0.0, 0.0), 1, false);
+            TestUtils.AreEqual(fmod(double3(323.4, double.PositiveInfinity, double.NaN), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(323.4, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.NegativeInfinity, -323.4, -0.0), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(0.0, 323.4, double.PositiveInfinity), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double3(double.NaN, double.NaN, double.NaN), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void fmod_double4()
+        {
+            TestUtils.AreEqual(fmod(double4(double.NegativeInfinity, -323.4, -0.0, 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double4(double.NaN, -323.4, -0.0, 0.0), 1, false);
+            TestUtils.AreEqual(fmod(double4(323.4, double.PositiveInfinity, double.NaN, double.NegativeInfinity), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -123.6)), double4(323.4, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(-323.4, -0.0, 0.0, 323.4), double4(-123.6, -123.6, -123.6, -123.6)), double4(-76.2, -0.0, 0.0, 76.2), 1, false);
+            TestUtils.AreEqual(fmod(double4(double.PositiveInfinity, double.NaN, double.NegativeInfinity, -323.4), double4(-123.6, -123.6, -0.0, -0.0)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(-0.0, 0.0, 323.4, double.PositiveInfinity), double4(-0.0, -0.0, -0.0, -0.0)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(double.NaN, double.NegativeInfinity, -323.4, -0.0), double4(-0.0, 0.0, 0.0, 0.0)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(0.0, 323.4, double.PositiveInfinity, double.NaN), double4(0.0, 0.0, 0.0, 0.0)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(double.NegativeInfinity, -323.4, -0.0, 0.0), double4(123.6, 123.6, 123.6, 123.6)), double4(double.NaN, -76.2, -0.0, 0.0), 1, false);
+            TestUtils.AreEqual(fmod(double4(323.4, double.PositiveInfinity, double.NaN, double.NegativeInfinity), double4(123.6, 123.6, 123.6, double.PositiveInfinity)), double4(76.2, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(-323.4, -0.0, 0.0, 323.4), double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(-323.4, -0.0, 0.0, 323.4), 1, false);
+            TestUtils.AreEqual(fmod(double4(double.PositiveInfinity, double.NaN, double.NegativeInfinity, -323.4), double4(double.PositiveInfinity, double.PositiveInfinity, double.NaN, double.NaN)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(-0.0, 0.0, 323.4, double.PositiveInfinity), double4(double.NaN, double.NaN, double.NaN, double.NaN)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(fmod(double4(double.NaN, double.NaN, double.NaN, double.NaN), double4(double.NaN, double.NaN, double.NaN, double.NaN)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_float()
+        {
+            TestUtils.AreEqual(pow(float.NegativeInfinity, float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, float.NegativeInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(0f, float.NegativeInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(3.4f, float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, float.NegativeInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(float.NaN, float.NegativeInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, -2.6f), 0f, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, -2.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, -2.6f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(0f, -2.6f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(3.4f, -2.6f), 0.0415102f, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, -2.6f), 0f, 1, false);
+            TestUtils.AreEqual(pow(float.NaN, -2.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(0f, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(3.4f, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, -0.0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(0f, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(3.4f, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, 0f), 1f, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, 2.6f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, 2.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, 2.6f), 0f, 1, false);
+            TestUtils.AreEqual(pow(0f, 2.6f), 0f, 1, false);
+            TestUtils.AreEqual(pow(3.4f, 2.6f), 24.0904655f, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, 2.6f), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(float.NaN, 2.6f), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, float.PositiveInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, float.PositiveInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, float.PositiveInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(0f, float.PositiveInfinity), 0f, 1, false);
+            TestUtils.AreEqual(pow(3.4f, float.PositiveInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, float.PositiveInfinity), float.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(float.NaN, float.PositiveInfinity), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.NegativeInfinity, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(-3.4f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(0f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(3.4f, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.PositiveInfinity, float.NaN), float.NaN, 1, false);
+            TestUtils.AreEqual(pow(float.NaN, float.NaN), float.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_float2()
+        {
+            TestUtils.AreEqual(pow(float2(float.NegativeInfinity, -3.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(0f, 0f), 1, false);
+            TestUtils.AreEqual(pow(float2(-0.0f, 0f), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(float.PositiveInfinity, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float2(3.4f, float.PositiveInfinity), float2(float.NegativeInfinity, float.NegativeInfinity)), float2(0f, 0f), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NaN, float.NegativeInfinity), float2(float.NegativeInfinity, -2.6f)), float2(float.NaN, 0f), 1, false);
+            TestUtils.AreEqual(pow(float2(-3.4f, -0.0f), float2(-2.6f, -2.6f)), float2(float.NaN, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float2(0f, 3.4f), float2(-2.6f, -2.6f)), float2(float.PositiveInfinity, 0.0415102f), 1, false);
+            TestUtils.AreEqual(pow(float2(float.PositiveInfinity, float.NaN), float2(-2.6f, -2.6f)), float2(0f, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NegativeInfinity, -3.4f), float2(-0.0f, -0.0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(-0.0f, 0f), float2(-0.0f, -0.0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(3.4f, float.PositiveInfinity), float2(-0.0f, -0.0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NegativeInfinity, -3.4f), float2(0f, 0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(-0.0f, 0f), float2(0f, 0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(3.4f, float.PositiveInfinity), float2(0f, 0f)), float2(1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NegativeInfinity, -3.4f), float2(2.6f, 2.6f)), float2(float.PositiveInfinity, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(-0.0f, 0f), float2(2.6f, 2.6f)), float2(0f, 0f), 1, false);
+            TestUtils.AreEqual(pow(float2(3.4f, float.PositiveInfinity), float2(2.6f, 2.6f)), float2(24.0904655f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NaN, float.NegativeInfinity), float2(2.6f, float.PositiveInfinity)), float2(float.NaN, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float2(-3.4f, -0.0f), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, 0f), 1, false);
+            TestUtils.AreEqual(pow(float2(0f, 3.4f), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(0f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float2(float.PositiveInfinity, float.NaN), float2(float.PositiveInfinity, float.PositiveInfinity)), float2(float.PositiveInfinity, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NegativeInfinity, -3.4f), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(-0.0f, 0f), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(3.4f, float.PositiveInfinity), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float2(float.NaN, float.NaN), float2(float.NaN, float.NaN)), float2(float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_float3()
+        {
+            TestUtils.AreEqual(pow(float3(float.NegativeInfinity, -3.4f, -0.0f), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float3(0f, 0f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float3(0f, 3.4f, float.PositiveInfinity), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float3(float.PositiveInfinity, 0f, 0f), 1, false);
+            TestUtils.AreEqual(pow(float3(float.NaN, float.NegativeInfinity, -3.4f), float3(float.NegativeInfinity, -2.6f, -2.6f)), float3(float.NaN, 0f, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float3(-0.0f, 0f, 3.4f), float3(-2.6f, -2.6f, -2.6f)), float3(float.PositiveInfinity, float.PositiveInfinity, 0.0415102f), 1, false);
+            TestUtils.AreEqual(pow(float3(float.PositiveInfinity, float.NaN, float.NegativeInfinity), float3(-2.6f, -2.6f, -0.0f)), float3(0f, float.NaN, 1f), 1, false);
+            TestUtils.AreEqual(pow(float3(-3.4f, -0.0f, 0f), float3(-0.0f, -0.0f, -0.0f)), float3(1f, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float3(3.4f, float.PositiveInfinity, float.NegativeInfinity), float3(-0.0f, -0.0f, 0f)), float3(1f, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float3(-3.4f, -0.0f, 0f), float3(0f, 0f, 0f)), float3(1f, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float3(3.4f, float.PositiveInfinity, float.NegativeInfinity), float3(0f, 0f, 2.6f)), float3(1f, 1f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float3(-3.4f, -0.0f, 0f), float3(2.6f, 2.6f, 2.6f)), float3(float.NaN, 0f, 0f), 1, false);
+            TestUtils.AreEqual(pow(float3(3.4f, float.PositiveInfinity, float.NaN), float3(2.6f, 2.6f, 2.6f)), float3(24.0904655f, float.PositiveInfinity, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float3(float.NegativeInfinity, -3.4f, -0.0f), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(float.PositiveInfinity, float.PositiveInfinity, 0f), 1, false);
+            TestUtils.AreEqual(pow(float3(0f, 3.4f, float.PositiveInfinity), float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float3(0f, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float3(float.NaN, float.NegativeInfinity, -3.4f), float3(float.PositiveInfinity, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float3(-0.0f, 0f, 3.4f), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float3(float.PositiveInfinity, float.NaN, float.NaN), float3(float.NaN, float.NaN, float.NaN)), float3(float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_float4()
+        {
+            TestUtils.AreEqual(pow(float4(float.NegativeInfinity, -3.4f, -0.0f, 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), float4(0f, 0f, float.PositiveInfinity, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float4(3.4f, float.PositiveInfinity, float.NaN, float.NegativeInfinity), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -2.6f)), float4(0f, 0f, float.NaN, 0f), 1, false);
+            TestUtils.AreEqual(pow(float4(-3.4f, -0.0f, 0f, 3.4f), float4(-2.6f, -2.6f, -2.6f, -2.6f)), float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, 0.0415102f), 1, false);
+            TestUtils.AreEqual(pow(float4(float.PositiveInfinity, float.NaN, float.NegativeInfinity, -3.4f), float4(-2.6f, -2.6f, -0.0f, -0.0f)), float4(0f, float.NaN, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float4(-0.0f, 0f, 3.4f, float.PositiveInfinity), float4(-0.0f, -0.0f, -0.0f, -0.0f)), float4(1f, 1f, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float4(float.NegativeInfinity, -3.4f, -0.0f, 0f), float4(0f, 0f, 0f, 0f)), float4(1f, 1f, 1f, 1f), 1, false);
+            TestUtils.AreEqual(pow(float4(3.4f, float.PositiveInfinity, float.NegativeInfinity, -3.4f), float4(0f, 0f, 2.6f, 2.6f)), float4(1f, 1f, float.PositiveInfinity, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float4(-0.0f, 0f, 3.4f, float.PositiveInfinity), float4(2.6f, 2.6f, 2.6f, 2.6f)), float4(0f, 0f, 24.0904655f, float.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(float4(float.NaN, float.NegativeInfinity, -3.4f, -0.0f), float4(2.6f, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(float.NaN, float.PositiveInfinity, float.PositiveInfinity, 0f), 1, false);
+            TestUtils.AreEqual(pow(float4(0f, 3.4f, float.PositiveInfinity, float.NaN), float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), float4(0f, float.PositiveInfinity, float.PositiveInfinity, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float4(float.NegativeInfinity, -3.4f, -0.0f, 0f), float4(float.NaN, float.NaN, float.NaN, float.NaN)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+            TestUtils.AreEqual(pow(float4(3.4f, float.PositiveInfinity, float.NaN, float.NaN), float4(float.NaN, float.NaN, float.NaN, float.NaN)), float4(float.NaN, float.NaN, float.NaN, float.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_double()
+        {
+            TestUtils.AreEqual(pow(double.NegativeInfinity, double.NegativeInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(-3.4, double.NegativeInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(-0.0, double.NegativeInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(0.0, double.NegativeInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(3.4, double.NegativeInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, double.NegativeInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(double.NaN, double.NegativeInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, -2.6), 0.0, 1, false);
+            TestUtils.AreEqual(pow(-3.4, -2.6), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0, -2.6), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(0.0, -2.6), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(3.4, -2.6), 0.041510199028461224, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, -2.6), 0.0, 1, false);
+            TestUtils.AreEqual(pow(double.NaN, -2.6), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(-3.4, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(-0.0, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(0.0, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(3.4, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, -0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(-3.4, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(-0.0, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(0.0, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(3.4, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, 0.0), 1.0, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, 2.6), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-3.4, 2.6), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0, 2.6), 0.0, 1, false);
+            TestUtils.AreEqual(pow(0.0, 2.6), 0.0, 1, false);
+            TestUtils.AreEqual(pow(3.4, 2.6), 24.090465076169735, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, 2.6), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(double.NaN, 2.6), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, double.PositiveInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-3.4, double.PositiveInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(-0.0, double.PositiveInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(0.0, double.PositiveInfinity), 0.0, 1, false);
+            TestUtils.AreEqual(pow(3.4, double.PositiveInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, double.PositiveInfinity), double.PositiveInfinity, 1, false);
+            TestUtils.AreEqual(pow(double.NaN, double.PositiveInfinity), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.NegativeInfinity, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(-3.4, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(-0.0, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(0.0, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(3.4, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.PositiveInfinity, double.NaN), double.NaN, 1, false);
+            TestUtils.AreEqual(pow(double.NaN, double.NaN), double.NaN, 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_double2()
+        {
+            TestUtils.AreEqual(pow(double2(double.NegativeInfinity, -3.4), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(0.0, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double2(-0.0, 0.0), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(double.PositiveInfinity, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double2(3.4, double.PositiveInfinity), double2(double.NegativeInfinity, double.NegativeInfinity)), double2(0.0, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NaN, double.NegativeInfinity), double2(double.NegativeInfinity, -2.6)), double2(double.NaN, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double2(-3.4, -0.0), double2(-2.6, -2.6)), double2(double.NaN, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double2(0.0, 3.4), double2(-2.6, -2.6)), double2(double.PositiveInfinity, 0.041510199028461224), 1, false);
+            TestUtils.AreEqual(pow(double2(double.PositiveInfinity, double.NaN), double2(-2.6, -2.6)), double2(0.0, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NegativeInfinity, -3.4), double2(-0.0, -0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(-0.0, 0.0), double2(-0.0, -0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(3.4, double.PositiveInfinity), double2(-0.0, -0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NegativeInfinity, -3.4), double2(0.0, 0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(-0.0, 0.0), double2(0.0, 0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(3.4, double.PositiveInfinity), double2(0.0, 0.0)), double2(1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NegativeInfinity, -3.4), double2(2.6, 2.6)), double2(double.PositiveInfinity, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(-0.0, 0.0), double2(2.6, 2.6)), double2(0.0, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double2(3.4, double.PositiveInfinity), double2(2.6, 2.6)), double2(24.090465076169735, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NaN, double.NegativeInfinity), double2(2.6, double.PositiveInfinity)), double2(double.NaN, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double2(-3.4, -0.0), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double2(0.0, 3.4), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(0.0, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double2(double.PositiveInfinity, double.NaN), double2(double.PositiveInfinity, double.PositiveInfinity)), double2(double.PositiveInfinity, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NegativeInfinity, -3.4), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(-0.0, 0.0), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(3.4, double.PositiveInfinity), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double2(double.NaN, double.NaN), double2(double.NaN, double.NaN)), double2(double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_double3()
+        {
+            TestUtils.AreEqual(pow(double3(double.NegativeInfinity, -3.4, -0.0), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double3(0.0, 0.0, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double3(0.0, 3.4, double.PositiveInfinity), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double3(double.PositiveInfinity, 0.0, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double3(double.NaN, double.NegativeInfinity, -3.4), double3(double.NegativeInfinity, -2.6, -2.6)), double3(double.NaN, 0.0, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double3(-0.0, 0.0, 3.4), double3(-2.6, -2.6, -2.6)), double3(double.PositiveInfinity, double.PositiveInfinity, 0.041510199028461224), 1, false);
+            TestUtils.AreEqual(pow(double3(double.PositiveInfinity, double.NaN, double.NegativeInfinity), double3(-2.6, -2.6, -0.0)), double3(0.0, double.NaN, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double3(-3.4, -0.0, 0.0), double3(-0.0, -0.0, -0.0)), double3(1.0, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double3(3.4, double.PositiveInfinity, double.NegativeInfinity), double3(-0.0, -0.0, 0.0)), double3(1.0, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double3(-3.4, -0.0, 0.0), double3(0.0, 0.0, 0.0)), double3(1.0, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double3(3.4, double.PositiveInfinity, double.NegativeInfinity), double3(0.0, 0.0, 2.6)), double3(1.0, 1.0, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double3(-3.4, -0.0, 0.0), double3(2.6, 2.6, 2.6)), double3(double.NaN, 0.0, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double3(3.4, double.PositiveInfinity, double.NaN), double3(2.6, 2.6, 2.6)), double3(24.090465076169735, double.PositiveInfinity, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double3(double.NegativeInfinity, -3.4, -0.0), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(double.PositiveInfinity, double.PositiveInfinity, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double3(0.0, 3.4, double.PositiveInfinity), double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double3(0.0, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double3(double.NaN, double.NegativeInfinity, -3.4), double3(double.PositiveInfinity, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double3(-0.0, 0.0, 3.4), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double3(double.PositiveInfinity, double.NaN, double.NaN), double3(double.NaN, double.NaN, double.NaN)), double3(double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void pow_double4()
+        {
+            TestUtils.AreEqual(pow(double4(double.NegativeInfinity, -3.4, -0.0, 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), double4(0.0, 0.0, double.PositiveInfinity, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double4(3.4, double.PositiveInfinity, double.NaN, double.NegativeInfinity), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -2.6)), double4(0.0, 0.0, double.NaN, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double4(-3.4, -0.0, 0.0, 3.4), double4(-2.6, -2.6, -2.6, -2.6)), double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, 0.041510199028461224), 1, false);
+            TestUtils.AreEqual(pow(double4(double.PositiveInfinity, double.NaN, double.NegativeInfinity, -3.4), double4(-2.6, -2.6, -0.0, -0.0)), double4(0.0, double.NaN, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double4(-0.0, 0.0, 3.4, double.PositiveInfinity), double4(-0.0, -0.0, -0.0, -0.0)), double4(1.0, 1.0, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double4(double.NegativeInfinity, -3.4, -0.0, 0.0), double4(0.0, 0.0, 0.0, 0.0)), double4(1.0, 1.0, 1.0, 1.0), 1, false);
+            TestUtils.AreEqual(pow(double4(3.4, double.PositiveInfinity, double.NegativeInfinity, -3.4), double4(0.0, 0.0, 2.6, 2.6)), double4(1.0, 1.0, double.PositiveInfinity, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double4(-0.0, 0.0, 3.4, double.PositiveInfinity), double4(2.6, 2.6, 2.6, 2.6)), double4(0.0, 0.0, 24.090465076169735, double.PositiveInfinity), 1, false);
+            TestUtils.AreEqual(pow(double4(double.NaN, double.NegativeInfinity, -3.4, -0.0), double4(2.6, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(double.NaN, double.PositiveInfinity, double.PositiveInfinity, 0.0), 1, false);
+            TestUtils.AreEqual(pow(double4(0.0, 3.4, double.PositiveInfinity, double.NaN), double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), double4(0.0, double.PositiveInfinity, double.PositiveInfinity, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double4(double.NegativeInfinity, -3.4, -0.0, 0.0), double4(double.NaN, double.NaN, double.NaN, double.NaN)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+            TestUtils.AreEqual(pow(double4(3.4, double.PositiveInfinity, double.NaN, double.NaN), double4(double.NaN, double.NaN, double.NaN, double.NaN)), double4(double.NaN, double.NaN, double.NaN, double.NaN), 1, false);
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_int()
+        {
+            TestUtils.AreEqual(ceilpow2(0), 0);
+            TestUtils.AreEqual(ceilpow2(1), 1);
+            TestUtils.AreEqual(ceilpow2(2), 2);
+            TestUtils.AreEqual(ceilpow2(3), 4);
+            TestUtils.AreEqual(ceilpow2(1019642234), 1073741824);
+            TestUtils.AreEqual(ceilpow2(1823423423), -2147483648);
+            TestUtils.AreEqual(ceilpow2(-2147483647), 0);
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_int2()
+        {
+            TestUtils.AreEqual(ceilpow2(int2(0, 1)), int2(0, 1));
+            TestUtils.AreEqual(ceilpow2(int2(2, 3)), int2(2, 4));
+            TestUtils.AreEqual(ceilpow2(int2(1019642234, 1823423423)), int2(1073741824, -2147483648));
+            TestUtils.AreEqual(ceilpow2(int2(-2147483647, -2147483647)), int2(0, 0));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_int3()
+        {
+            TestUtils.AreEqual(ceilpow2(int3(0, 1, 2)), int3(0, 1, 2));
+            TestUtils.AreEqual(ceilpow2(int3(3, 1019642234, 1823423423)), int3(4, 1073741824, -2147483648));
+            TestUtils.AreEqual(ceilpow2(int3(-2147483647, -2147483647, -2147483647)), int3(0, 0, 0));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_int4()
+        {
+            TestUtils.AreEqual(ceilpow2(int4(0, 1, 2, 3)), int4(0, 1, 2, 4));
+            TestUtils.AreEqual(ceilpow2(int4(1019642234, 1823423423, -2147483647, -2147483647)), int4(1073741824, -2147483648, 0, 0));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_uint()
+        {
+            TestUtils.AreEqual(ceilpow2(0u), 0u);
+            TestUtils.AreEqual(ceilpow2(1u), 1u);
+            TestUtils.AreEqual(ceilpow2(2u), 2u);
+            TestUtils.AreEqual(ceilpow2(3u), 4u);
+            TestUtils.AreEqual(ceilpow2(1019642234u), 1073741824u);
+            TestUtils.AreEqual(ceilpow2(1823423423u), 2147483648u);
+            TestUtils.AreEqual(ceilpow2(4294967295u), 0u);
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_uint2()
+        {
+            TestUtils.AreEqual(ceilpow2(uint2(0u, 1u)), uint2(0u, 1u));
+            TestUtils.AreEqual(ceilpow2(uint2(2u, 3u)), uint2(2u, 4u));
+            TestUtils.AreEqual(ceilpow2(uint2(1019642234u, 1823423423u)), uint2(1073741824u, 2147483648u));
+            TestUtils.AreEqual(ceilpow2(uint2(4294967295u, 4294967295u)), uint2(0u, 0u));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_uint3()
+        {
+            TestUtils.AreEqual(ceilpow2(uint3(0u, 1u, 2u)), uint3(0u, 1u, 2u));
+            TestUtils.AreEqual(ceilpow2(uint3(3u, 1019642234u, 1823423423u)), uint3(4u, 1073741824u, 2147483648u));
+            TestUtils.AreEqual(ceilpow2(uint3(4294967295u, 4294967295u, 4294967295u)), uint3(0u, 0u, 0u));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_uint4()
+        {
+            TestUtils.AreEqual(ceilpow2(uint4(0u, 1u, 2u, 3u)), uint4(0u, 1u, 2u, 4u));
+            TestUtils.AreEqual(ceilpow2(uint4(1019642234u, 1823423423u, 4294967295u, 4294967295u)), uint4(1073741824u, 2147483648u, 0u, 0u));
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_long()
+        {
+            TestUtils.AreEqual(ceilpow2(0L), 0L);
+            TestUtils.AreEqual(ceilpow2(1L), 1L);
+            TestUtils.AreEqual(ceilpow2(2L), 2L);
+            TestUtils.AreEqual(ceilpow2(3L), 4L);
+            TestUtils.AreEqual(ceilpow2(1019642234L), 1073741824L);
+            TestUtils.AreEqual(ceilpow2(1823423423L), 2147483648L);
+            TestUtils.AreEqual(ceilpow2(2147483648L), 2147483648L);
+            TestUtils.AreEqual(ceilpow2(4294967295L), 4294967296L);
+            TestUtils.AreEqual(ceilpow2(4294967296L), 4294967296L);
+            TestUtils.AreEqual(ceilpow2(7227372236554874814L), -9223372036854775808L);
+            TestUtils.AreEqual(ceilpow2(-100L), 0L);
+        }
+
+        [TestCompiler]
+        public static void ceilpow2_ulong()
+        {
+            TestUtils.AreEqual(ceilpow2(0UL), 0UL);
+            TestUtils.AreEqual(ceilpow2(1UL), 1UL);
+            TestUtils.AreEqual(ceilpow2(2UL), 2UL);
+            TestUtils.AreEqual(ceilpow2(3UL), 4UL);
+            TestUtils.AreEqual(ceilpow2(1019642234UL), 1073741824UL);
+            TestUtils.AreEqual(ceilpow2(1823423423UL), 2147483648UL);
+            TestUtils.AreEqual(ceilpow2(2147483648UL), 2147483648UL);
+            TestUtils.AreEqual(ceilpow2(4294967295UL), 4294967296UL);
+            TestUtils.AreEqual(ceilpow2(4294967296UL), 4294967296UL);
+            TestUtils.AreEqual(ceilpow2(7227372236554874814UL), 9223372036854775808UL);
+            TestUtils.AreEqual(ceilpow2(10223372036854775808UL), 0UL);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..429eec9afab809a1ee60ac66339e54841ca6db34
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMath.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a9baee454a793140a0be3d7d81d09ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6912877b429b39ecf9ce947210b380401e3e10c0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs
@@ -0,0 +1,1152 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    class TestMatrix
+    {
+        [TestCompiler]
+        public static void float2x2_constructor_columns()
+        {
+            float2x2 a = float2x2(float2(1.0f, 2.0f),
+                                  float2(3.0f, 4.0f));
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c0.y, 2.0f);
+            TestUtils.AreEqual(a.c1.x, 3.0f);
+            TestUtils.AreEqual(a.c1.y, 4.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_constructor_columns()
+        {
+            float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f),
+                                  float3(4.0f, 5.0f, 6.0f),
+                                  float3(7.0f, 8.0f, 9.0f));
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c0.y, 2.0f);
+            TestUtils.AreEqual(a.c0.z, 3.0f);
+            TestUtils.AreEqual(a.c1.x, 4.0f);
+            TestUtils.AreEqual(a.c1.y, 5.0f);
+            TestUtils.AreEqual(a.c1.z, 6.0f);
+            TestUtils.AreEqual(a.c2.x, 7.0f);
+            TestUtils.AreEqual(a.c2.y, 8.0f);
+            TestUtils.AreEqual(a.c2.z, 9.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_constructor_columns()
+        {
+            float4x4 a = float4x4(float4( 1.0f,  2.0f,  3.0f,  4.0f),
+                                  float4( 5.0f,  6.0f,  7.0f,  8.0f),
+                                  float4( 9.0f, 10.0f, 11.0f, 12.0f),
+                                  float4(13.0f, 14.0f, 15.0f, 16.0f));
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c0.y, 2.0f);
+            TestUtils.AreEqual(a.c0.z, 3.0f);
+            TestUtils.AreEqual(a.c0.w, 4.0f);
+            TestUtils.AreEqual(a.c1.x, 5.0f);
+            TestUtils.AreEqual(a.c1.y, 6.0f);
+            TestUtils.AreEqual(a.c1.z, 7.0f);
+            TestUtils.AreEqual(a.c1.w, 8.0f);
+            TestUtils.AreEqual(a.c2.x, 9.0f);
+            TestUtils.AreEqual(a.c2.y, 10.0f);
+            TestUtils.AreEqual(a.c2.z, 11.0f);
+            TestUtils.AreEqual(a.c2.w, 12.0f);
+            TestUtils.AreEqual(a.c3.x, 13.0f);
+            TestUtils.AreEqual(a.c3.y, 14.0f);
+            TestUtils.AreEqual(a.c3.z, 15.0f);
+            TestUtils.AreEqual(a.c3.w, 16.0f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_constructor_scalars()
+        {
+            float2x2 a = float2x2(1.0f, 2.0f,
+                                  3.0f, 4.0f);
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 2.0f);
+            TestUtils.AreEqual(a.c0.y, 3.0f);
+            TestUtils.AreEqual(a.c1.y, 4.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_constructor_scalars()
+        {
+            float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
+                                  4.0f, 5.0f, 6.0f,
+                                  7.0f, 8.0f, 9.0f);
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 2.0f);
+            TestUtils.AreEqual(a.c2.x, 3.0f);
+            TestUtils.AreEqual(a.c0.y, 4.0f);
+            TestUtils.AreEqual(a.c1.y, 5.0f);
+            TestUtils.AreEqual(a.c2.y, 6.0f);
+            TestUtils.AreEqual(a.c0.z, 7.0f);
+            TestUtils.AreEqual(a.c1.z, 8.0f);
+            TestUtils.AreEqual(a.c2.z, 9.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_constructor_scalars()
+        {
+            float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
+                                   5.0f,  6.0f,  7.0f,  8.0f,
+                                   9.0f, 10.0f, 11.0f, 12.0f,
+                                  13.0f, 14.0f, 15.0f, 16.0f);
+
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 2.0f);
+            TestUtils.AreEqual(a.c2.x, 3.0f);
+            TestUtils.AreEqual(a.c3.x, 4.0f);
+            TestUtils.AreEqual(a.c0.y, 5.0f);
+            TestUtils.AreEqual(a.c1.y, 6.0f);
+            TestUtils.AreEqual(a.c2.y, 7.0f);
+            TestUtils.AreEqual(a.c3.y, 8.0f);
+            TestUtils.AreEqual(a.c0.z, 9.0f);
+            TestUtils.AreEqual(a.c1.z, 10.0f);
+            TestUtils.AreEqual(a.c2.z, 11.0f);
+            TestUtils.AreEqual(a.c3.z, 12.0f);
+            TestUtils.AreEqual(a.c0.w, 13.0f);
+            TestUtils.AreEqual(a.c1.w, 14.0f);
+            TestUtils.AreEqual(a.c2.w, 15.0f);
+            TestUtils.AreEqual(a.c3.w, 16.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_constructor_float3x3()
+        {
+            float3x3 rot = float3x3(1.0f, 2.0f, 3.0f,
+                                    4.0f, 5.0f, 6.0f,
+                                    7.0f, 8.0f, 9.0f);
+            float3 pos = float3(10.0f, 11.0f, 12.0f);
+            float4x4 m = float4x4(rot, pos);
+
+            float4x4 r = float4x4(1.0f, 2.0f, 3.0f, 10.0f,
+                                  4.0f, 5.0f, 6.0f, 11.0f,
+                                  7.0f, 8.0f, 9.0f, 12.0f,
+                                  0.0f, 0.0f, 0.0f, 1.0f);
+            TestUtils.AreEqual(m, r);
+        }
+
+
+        [TestCompiler]
+        public static void float3x3_constructor_quaternion()
+        {
+            float3x3 m = float3x3(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)));
+
+            float3x3 r = float3x3( 0.12774f, -0.64529f, 0.75318f,
+                                   0.89975f,  0.39491f, 0.18575f,
+                                  -0.41730f,  0.65394f, 0.63104f);
+
+            TestUtils.AreEqual(m, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_constructor_quaternion_position()
+        {
+            float4x4 m = float4x4(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)), float3(1.0f, 2.0f, 3.0f));
+
+            float4x4 r = float4x4( 0.12774f, -0.64529f, 0.75318f, 1.0f,
+                                   0.89975f,  0.39491f, 0.18575f, 2.0f,
+                                  -0.41730f,  0.65394f, 0.63104f, 3.0f,
+                                   0.0f,      0.0f,     0.0f,     1.0f);
+
+            TestUtils.AreEqual(m, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_identity()
+        {
+            float2x2 a = float2x2.identity;
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 0.0f);
+            TestUtils.AreEqual(a.c0.y, 0.0f);
+            TestUtils.AreEqual(a.c1.y, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_identity()
+        {
+            float3x3 a = float3x3.identity;
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 0.0f);
+            TestUtils.AreEqual(a.c2.x, 0.0f);
+            TestUtils.AreEqual(a.c0.y, 0.0f);
+            TestUtils.AreEqual(a.c1.y, 1.0f);
+            TestUtils.AreEqual(a.c2.y, 0.0f);
+            TestUtils.AreEqual(a.c0.z, 0.0f);
+            TestUtils.AreEqual(a.c1.z, 0.0f);
+            TestUtils.AreEqual(a.c2.z, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_identity()
+        {
+            float4x4 a = float4x4.identity;
+            TestUtils.AreEqual(a.c0.x, 1.0f);
+            TestUtils.AreEqual(a.c1.x, 0.0f);
+            TestUtils.AreEqual(a.c2.x, 0.0f);
+            TestUtils.AreEqual(a.c3.x, 0.0f);
+            TestUtils.AreEqual(a.c0.y, 0.0f);
+            TestUtils.AreEqual(a.c1.y, 1.0f);
+            TestUtils.AreEqual(a.c2.y, 0.0f);
+            TestUtils.AreEqual(a.c3.y, 0.0f);
+            TestUtils.AreEqual(a.c0.z, 0.0f);
+            TestUtils.AreEqual(a.c1.z, 0.0f);
+            TestUtils.AreEqual(a.c2.z, 1.0f);
+            TestUtils.AreEqual(a.c3.z, 0.0f);
+            TestUtils.AreEqual(a.c0.w, 0.0f);
+            TestUtils.AreEqual(a.c1.w, 0.0f);
+            TestUtils.AreEqual(a.c2.w, 0.0f);
+            TestUtils.AreEqual(a.c3.w, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_rotate()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float2x2 m = float2x2.Rotate(angle);
+            TestUtils.AreEqual(m.c0.x, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c0.y, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.x, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.y, cos(angle), epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x3_axis_angle()
+        {
+            float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
+            float angle = 2.7f;
+
+            float3x3 r = float3x3(quaternion.AxisAngle(axis, angle));
+            float3x3 m = float3x3.AxisAngle(axis, angle);
+            TestUtils.AreEqual(m, r, 0.00001f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_axis_angle_consistency()
+        {
+            TestUtils.AreEqual(float3x3.AxisAngle(float3(1, 0, 0), 1.0f), float3x3.RotateX(1.0f), 0.001f);
+            TestUtils.AreEqual(float3x3.AxisAngle(float3(0, 1, 0), 1.0f), float3x3.RotateY(1.0f), 0.001f);
+            TestUtils.AreEqual(float3x3.AxisAngle(float3(0, 0, 1), 1.0f), float3x3.RotateZ(1.0f), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_rotate_x()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float3x3 m = float3x3.RotateX(angle);
+            TestUtils.AreEqual(m.c0.x, 1.0f, epsilon);
+            TestUtils.AreEqual(m.c0.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.y, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c1.z, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c2.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.y, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c2.z, cos(angle), epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x3_rotate_y()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float3x3 m = float3x3.RotateY(angle);
+            TestUtils.AreEqual(m.c0.x, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c0.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.z, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.y, 1.0f, epsilon);
+            TestUtils.AreEqual(m.c1.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.x, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c2.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.z, cos(angle), epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x3_rotate_z()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float3x3 m = float3x3.RotateZ(angle);
+            TestUtils.AreEqual(m.c0.x, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c0.y, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c0.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.x, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.y, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c1.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.z, 1.0f, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x3_rotate_x_handedness()
+        {
+            float3 a = float3(0.0f, 0.3f, 0.7f);
+            float3x3 m = float3x3.RotateX(0.3f);
+            float3 b = mul(m, a);
+            float w = cross(a, b).x;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+
+        [TestCompiler]
+        public static void float3x3_rotate_y_handedness()
+        {
+            float3 a = float3(0.3f, 0.0f, 0.7f);
+            float3x3 m = float3x3.RotateY(0.3f);
+            float3 b = mul(m, a);
+            float w = cross(a, b).y;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_rotate_z_handedness()
+        {
+            float3 a = float3(0.3f, 0.7f, 0.0f);
+            float3x3 m = float3x3.RotateZ(0.3f);
+            float3 b = mul(m, a);
+            float w = cross(a, b).z;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_axis_angle()
+        {
+            float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
+            float angle = 2.7f;
+
+            float4x4 r = float4x4(quaternion.AxisAngle(axis, angle), float3.zero);
+            float4x4 m = float4x4.AxisAngle(axis, angle);
+            TestUtils.AreEqual(m, r, 0.00001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_axis_angle_consistency()
+        {
+            TestUtils.AreEqual(float4x4.AxisAngle(float3(1, 0, 0), 1.0f), float4x4.RotateX(1.0f), 0.001f);
+            TestUtils.AreEqual(float4x4.AxisAngle(float3(0, 1, 0), 1.0f), float4x4.RotateY(1.0f), 0.001f);
+            TestUtils.AreEqual(float4x4.AxisAngle(float3(0, 0, 1), 1.0f), float4x4.RotateZ(1.0f), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_rotate_x()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float4x4 m = float4x4.RotateX(angle);
+            TestUtils.AreEqual(m.c0.x, 1.0f, epsilon);
+            TestUtils.AreEqual(m.c0.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.y, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c1.z, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.y, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c2.z, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c2.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.w, 1.0f, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float4x4_rotate_y()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float4x4 m = float4x4.RotateY(angle);
+            TestUtils.AreEqual(m.c0.x, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c0.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.z, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c0.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.y, 1.0f, epsilon);
+            TestUtils.AreEqual(m.c1.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.x, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c2.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.z, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c2.w, 0.0f);
+            TestUtils.AreEqual(m.c3.x, 0.0f);
+            TestUtils.AreEqual(m.c3.y, 0.0f);
+            TestUtils.AreEqual(m.c3.z, 0.0f);
+            TestUtils.AreEqual(m.c3.w, 1.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_rotate_z()
+        {
+            float epsilon = 0.0001f;
+            float angle = 10.3f;
+            float4x4 m = float4x4.RotateZ(angle);
+            TestUtils.AreEqual(m.c0.x, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c0.y, sin(angle), epsilon);
+            TestUtils.AreEqual(m.c0.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c0.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.x, -sin(angle), epsilon);
+            TestUtils.AreEqual(m.c1.y, cos(angle), epsilon);
+            TestUtils.AreEqual(m.c1.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c1.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c2.z, 1.0f, epsilon);
+            TestUtils.AreEqual(m.c2.w, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.x, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.y, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.z, 0.0f, epsilon);
+            TestUtils.AreEqual(m.c3.w, 1.0f, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float4x4_rotate_x_handedness()
+        {
+            float3 a = float3(0.0f, 0.3f, 0.7f);
+            float4x4 m = float4x4.RotateX(0.3f);
+            float3 b = rotate(m, a);
+            float w = cross(a, b).x;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+
+        [TestCompiler]
+        public static void float4x4_rotate_y_handedness()
+        {
+            float3 a = float3(0.3f, 0.0f, 0.7f);
+            float4x4 m = float4x4.RotateY(0.3f);
+            float3 b = rotate(m, a);
+            float w = cross(a, b).y;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_rotate_z_handedness()
+        {
+            float3 a = float3(0.3f, 0.7f, 0.0f);
+            float4x4 m = float4x4.RotateZ(0.3f);
+            float3 b = rotate(m, a);
+            float w = cross(a, b).z;
+            TestUtils.AreEqual(true, w > 0.0f);
+        }
+
+
+        // rotation by (-50, 28, 39) degrees from Max
+        static internal readonly float3 test_angles = math.radians(float3(-50.0f, 28.0f, 39.0f));
+
+        static internal readonly float3x3 test3x3_xyz = new float3x3( 0.686179155968f, -0.684009078513f, -0.247567660300f,
+                                                0.555656924414f,  0.273213475262f,  0.785238676636f,
+                                               -0.469471562786f, -0.676377097075f,  0.567547772692f);
+
+        static internal readonly float3x3 test3x3_xzy = new float3x3( 0.686179155968f, -0.716805468125f, -0.123887395569f,
+                                                0.629320391050f,  0.499539794942f,  0.595328345266f,
+                                               -0.364847929038f, -0.486466765705f,  0.793874092373f);
+
+        static internal readonly float3x3 test3x3_yxz = new float3x3( 0.912505475649f, -0.404519349890f, -0.0608099701904f,
+                                                0.276167195792f,  0.499539794942f,  0.8210917568930f,
+                                               -0.301770503659f, -0.766044443119f,  0.5675477726920f);
+
+        static internal readonly float3x3 test3x3_yzx = new float3x3( 0.68617915596800f, -0.629320391050f, 0.364847929038f,
+                                               -0.00246669562435f,  0.499539794942f, 0.866287428445f,
+                                               -0.72742840288700f, -0.595328345266f, 0.341221453011f);
+
+        static internal readonly float3x3 test3x3_zxy = new float3x3( 0.459852836288f, -0.835146653037f, 0.301770503659f,
+                                                0.404519349890f,  0.499539794942f, 0.766044443119f,
+                                               -0.790505828266f, -0.230195701935f, 0.567547772692f);
+
+        static internal readonly float3x3 test3x3_zyx = new float3x3( 0.686179155968f, -0.555656924414f, 0.469471562786f,
+                                                0.125029621267f,  0.725866114623f, 0.676377097075f,
+                                               -0.716607116711f, -0.405418013897f, 0.567547772692f);
+
+
+        static internal readonly float4x4 test4x4_xyz = new float4x4(test3x3_xyz, new float3(0, 0, 0));
+        static internal readonly float4x4 test4x4_xzy = new float4x4(test3x3_xzy, new float3(0, 0, 0));
+        static internal readonly float4x4 test4x4_yxz = new float4x4(test3x3_yxz, new float3(0, 0, 0));
+        static internal readonly float4x4 test4x4_yzx = new float4x4(test3x3_yzx, new float3(0, 0, 0));
+        static internal readonly float4x4 test4x4_zxy = new float4x4(test3x3_zxy, new float3(0, 0, 0));
+        static internal readonly float4x4 test4x4_zyx = new float4x4(test3x3_zyx, new float3(0, 0, 0));
+
+
+        [TestCompiler]
+        public static void float3x3_euler()
+        {
+            float3x3 m0_xyz = float3x3.EulerXYZ(test_angles);
+            float3x3 m0_xzy = float3x3.EulerXZY(test_angles);
+            float3x3 m0_yxz = float3x3.EulerYXZ(test_angles);
+            float3x3 m0_yzx = float3x3.EulerYZX(test_angles);
+            float3x3 m0_zxy = float3x3.EulerZXY(test_angles);
+            float3x3 m0_zyx = float3x3.EulerZYX(test_angles);
+
+            float3x3 m1 = float3x3.Euler(test_angles);
+            float3x3 m1_xyz = float3x3.Euler(test_angles, RotationOrder.XYZ);
+            float3x3 m1_xzy = float3x3.Euler(test_angles, RotationOrder.XZY);
+            float3x3 m1_yxz = float3x3.Euler(test_angles, RotationOrder.YXZ);
+            float3x3 m1_yzx = float3x3.Euler(test_angles, RotationOrder.YZX);
+            float3x3 m1_zxy = float3x3.Euler(test_angles, RotationOrder.ZXY);
+            float3x3 m1_zyx = float3x3.Euler(test_angles, RotationOrder.ZYX);
+
+
+            float3x3 m2_xyz = float3x3.EulerXYZ(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m2_xzy = float3x3.EulerXZY(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m2_yxz = float3x3.EulerYXZ(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m2_yzx = float3x3.EulerYZX(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m2_zxy = float3x3.EulerZXY(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m2_zyx = float3x3.EulerZYX(test_angles.x, test_angles.y, test_angles.z);
+
+            float3x3 m3 = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z);
+            float3x3 m3_xyz = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XYZ);
+            float3x3 m3_xzy = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XZY);
+            float3x3 m3_yxz = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YXZ);
+            float3x3 m3_yzx = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YZX);
+            float3x3 m3_zxy = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZXY);
+            float3x3 m3_zyx = float3x3.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZYX);
+
+
+            TestUtils.AreEqual(m0_xyz, test3x3_xyz, 0.0001f);
+            TestUtils.AreEqual(m0_yzx, test3x3_yzx, 0.0001f);
+            TestUtils.AreEqual(m0_zxy, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m0_xzy, test3x3_xzy, 0.0001f);
+            TestUtils.AreEqual(m0_yxz, test3x3_yxz, 0.0001f);
+            TestUtils.AreEqual(m0_zyx, test3x3_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m1, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m1_xyz, test3x3_xyz, 0.0001f);
+            TestUtils.AreEqual(m1_yzx, test3x3_yzx, 0.0001f);
+            TestUtils.AreEqual(m1_zxy, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m1_xzy, test3x3_xzy, 0.0001f);
+            TestUtils.AreEqual(m1_yxz, test3x3_yxz, 0.0001f);
+            TestUtils.AreEqual(m1_zyx, test3x3_zyx, 0.0001f);
+
+
+            TestUtils.AreEqual(m2_xyz, test3x3_xyz, 0.0001f);
+            TestUtils.AreEqual(m2_yzx, test3x3_yzx, 0.0001f);
+            TestUtils.AreEqual(m2_zxy, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m2_xzy, test3x3_xzy, 0.0001f);
+            TestUtils.AreEqual(m2_yxz, test3x3_yxz, 0.0001f);
+            TestUtils.AreEqual(m2_zyx, test3x3_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m3, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m3_xyz, test3x3_xyz, 0.0001f);
+            TestUtils.AreEqual(m3_yzx, test3x3_yzx, 0.0001f);
+            TestUtils.AreEqual(m3_zxy, test3x3_zxy, 0.0001f);
+            TestUtils.AreEqual(m3_xzy, test3x3_xzy, 0.0001f);
+            TestUtils.AreEqual(m3_yxz, test3x3_yxz, 0.0001f);
+            TestUtils.AreEqual(m3_zyx, test3x3_zyx, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_euler()
+        {
+            float4x4 m0_xyz = float4x4.EulerXYZ(test_angles);
+            float4x4 m0_xzy = float4x4.EulerXZY(test_angles);
+            float4x4 m0_yxz = float4x4.EulerYXZ(test_angles);
+            float4x4 m0_yzx = float4x4.EulerYZX(test_angles);
+            float4x4 m0_zxy = float4x4.EulerZXY(test_angles);
+            float4x4 m0_zyx = float4x4.EulerZYX(test_angles);
+
+            float4x4 m1 = float4x4.Euler(test_angles);
+            float4x4 m1_xyz = float4x4.Euler(test_angles, RotationOrder.XYZ);
+            float4x4 m1_xzy = float4x4.Euler(test_angles, RotationOrder.XZY);
+            float4x4 m1_yxz = float4x4.Euler(test_angles, RotationOrder.YXZ);
+            float4x4 m1_yzx = float4x4.Euler(test_angles, RotationOrder.YZX);
+            float4x4 m1_zxy = float4x4.Euler(test_angles, RotationOrder.ZXY);
+            float4x4 m1_zyx = float4x4.Euler(test_angles, RotationOrder.ZYX);
+
+            
+            float4x4 m2_xyz = float4x4.EulerXYZ(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m2_xzy = float4x4.EulerXZY(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m2_yxz = float4x4.EulerYXZ(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m2_yzx = float4x4.EulerYZX(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m2_zxy = float4x4.EulerZXY(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m2_zyx = float4x4.EulerZYX(test_angles.x, test_angles.y, test_angles.z);
+
+            float4x4 m3 = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z);
+            float4x4 m3_xyz = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XYZ);
+            float4x4 m3_xzy = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XZY);
+            float4x4 m3_yxz = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YXZ);
+            float4x4 m3_yzx = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YZX);
+            float4x4 m3_zxy = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZXY);
+            float4x4 m3_zyx = float4x4.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZYX);
+
+            
+            TestUtils.AreEqual(m0_xyz, test4x4_xyz, 0.0001f);
+            TestUtils.AreEqual(m0_yzx, test4x4_yzx, 0.0001f);
+            TestUtils.AreEqual(m0_zxy, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m0_xzy, test4x4_xzy, 0.0001f);
+            TestUtils.AreEqual(m0_yxz, test4x4_yxz, 0.0001f);
+            TestUtils.AreEqual(m0_zyx, test4x4_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m1, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m1_xyz, test4x4_xyz, 0.0001f);
+            TestUtils.AreEqual(m1_yzx, test4x4_yzx, 0.0001f);
+            TestUtils.AreEqual(m1_zxy, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m1_xzy, test4x4_xzy, 0.0001f);
+            TestUtils.AreEqual(m1_yxz, test4x4_yxz, 0.0001f);
+            TestUtils.AreEqual(m1_zyx, test4x4_zyx, 0.0001f);
+
+            
+            TestUtils.AreEqual(m2_xyz, test4x4_xyz, 0.0001f);
+            TestUtils.AreEqual(m2_yzx, test4x4_yzx, 0.0001f);
+            TestUtils.AreEqual(m2_zxy, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m2_xzy, test4x4_xzy, 0.0001f);
+            TestUtils.AreEqual(m2_yxz, test4x4_yxz, 0.0001f);
+            TestUtils.AreEqual(m2_zyx, test4x4_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m3, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m3_xyz, test4x4_xyz, 0.0001f);
+            TestUtils.AreEqual(m3_yzx, test4x4_yzx, 0.0001f);
+            TestUtils.AreEqual(m3_zxy, test4x4_zxy, 0.0001f);
+            TestUtils.AreEqual(m3_xzy, test4x4_xzy, 0.0001f);
+            TestUtils.AreEqual(m3_yxz, test4x4_yxz, 0.0001f);
+            TestUtils.AreEqual(m3_zyx, test4x4_zyx, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_scale()
+        {
+            float2x2 m = float2x2(1.0f, 2.0f,
+                                  3.0f, 4.0f);
+
+            float2x2 r0 = float2x2(2.0f, 4.0f,
+                                   6.0f, 8.0f);
+
+            float2x2 r1 = float2x2(2.0f,  4.0f,
+                                   9.0f, 12.0f);
+
+            float2x2 a = mul(float2x2.Scale(2.0f), m);
+            float2x2 b = mul(float2x2.Scale(2.0f, 3.0f), m);
+            float2x2 c = mul(float2x2.Scale(2.0f, 3.0f), m);
+
+            TestUtils.AreEqual(a, r0);
+            TestUtils.AreEqual(b, r1);
+            TestUtils.AreEqual(c, r1);
+        }
+
+        [TestCompiler]
+        public static void float3x3_scale()
+        {
+            float3x3 m = float3x3(1.0f, 2.0f, 3.0f,
+                                  4.0f, 5.0f, 6.0f,
+                                  7.0f, 8.0f, 9.0f);
+
+
+            float3x3 r0 = float3x3( 2.0f,  4.0f,  6.0f,
+                                    8.0f, 10.0f, 12.0f,
+                                   14.0f, 16.0f, 18.0f);
+
+            float3x3 r1 = float3x3( 2.0f,  4.0f,  6.0f,
+                                   12.0f, 15.0f, 18.0f,
+                                   28.0f, 32.0f, 36.0f);
+
+
+            float3x3 a = mul(float3x3.Scale(2.0f), m);
+            float3x3 b = mul(float3x3.Scale(2.0f, 3.0f, 4.0f), m);
+            float3x3 c = mul(float3x3.Scale(2.0f, 3.0f, 4.0f), m);
+
+            TestUtils.AreEqual(a, r0);
+            TestUtils.AreEqual(b, r1);
+            TestUtils.AreEqual(c, r1);
+        }
+
+        [TestCompiler]
+        public static void float4x4_scale()
+        {
+            float4x4 m = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
+                                   5.0f,  6.0f,  7.0f,  8.0f,
+                                   9.0f, 10.0f, 11.0f, 12.0f,
+                                  13.0f, 14.0f, 15.0f, 16.0f);
+
+            float4x4 r0 = float4x4( 2.0f,  4.0f,  6.0f,  8.0f,
+                                   10.0f, 12.0f, 14.0f, 16.0f,
+                                   18.0f, 20.0f, 22.0f, 24.0f,
+                                   13.0f, 14.0f, 15.0f, 16.0f);
+
+            float4x4 r1 = float4x4( 2.0f,  4.0f,  6.0f,  8.0f,
+                                   15.0f, 18.0f, 21.0f, 24.0f,
+                                   36.0f, 40.0f, 44.0f, 48.0f,
+                                   13.0f, 14.0f, 15.0f, 16.0f);
+
+            float4x4 a = mul(float4x4.Scale(2.0f), m);
+            float4x4 b = mul(float4x4.Scale(2.0f, 3.0f, 4.0f), m);
+            float4x4 c = mul(float4x4.Scale(2.0f, 3.0f, 4.0f), m);
+
+            TestUtils.AreEqual(a, r0);
+            TestUtils.AreEqual(b, r1);
+            TestUtils.AreEqual(c, r1);
+        }
+
+        [TestCompiler]
+        public static void float2x2_matrix_mul()
+        {
+            // http://www.wolframalpha.com/input/?i=%5B%5B1,2%5D,%5B3,4%5D%5D*%5B%5B21,22%5D,%5B23,24%5D%5D
+            float2x2 a = float2x2(1.0f, 2.0f,
+                                  3.0f, 4.0f);
+
+            float2x2 b = float2x2(21.0f, 22.0f,
+                                  23.0f, 24.0f);
+
+            float2x2 c = mul(a, b);
+            TestUtils.AreEqual(c.c0.x, 67.0f);
+            TestUtils.AreEqual(c.c1.x, 70.0f);
+
+            TestUtils.AreEqual(c.c0.y, 155.0f);
+            TestUtils.AreEqual(c.c1.y, 162.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_matrix_mul()
+        {
+            // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3%5D,%5B4,5,6%5D,%5B7,8,9%5D%5D*%5B%5B21,22,23%5D,%5B24,25,26%5D,%5B27,28,29%5D%5D
+            float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
+                                  4.0f, 5.0f, 6.0f,
+                                  7.0f, 8.0f, 9.0f);
+
+            float3x3 b = float3x3(21.0f, 22.0f, 23.0f,
+                                  24.0f, 25.0f, 26.0f,
+                                  27.0f, 28.0f, 29.0f);
+
+            float3x3 c = mul(a, b);
+            TestUtils.AreEqual(c.c0.x, 150.0f);
+            TestUtils.AreEqual(c.c1.x, 156.0f);
+            TestUtils.AreEqual(c.c2.x, 162.0f);
+
+            TestUtils.AreEqual(c.c0.y, 366.0f);
+            TestUtils.AreEqual(c.c1.y, 381.0f);
+            TestUtils.AreEqual(c.c2.y, 396.0f);
+
+            TestUtils.AreEqual(c.c0.z, 582.0f);
+            TestUtils.AreEqual(c.c1.z, 606.0f);
+            TestUtils.AreEqual(c.c2.z, 630.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_matrix_mul()
+        {
+            // https://fogbugz.unity3d.com/f/cases/1041176/
+            // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3,4%5D,%5B5,6,7,8%5D,%5B9,10,11,12%5D,%5B13,14,15,16%5D%5D*%5B%5B21,22,23,24%5D,%5B25,26,27,28%5D,%5B29,30,31,32%5D,%5B33,34,35,36%5D%5D
+            float4x4 a = float4x4( 1.0f, 2.0f, 3.0f, 4.0f,
+                                   5.0f, 6.0f, 7.0f, 8.0f,
+                                   9.0f,10.0f,11.0f,12.0f,
+                                  13.0f,14.0f,15.0f,16.0f);
+
+            float4x4 b = float4x4(21.0f,22.0f,23.0f,24.0f,
+                                  25.0f,26.0f,27.0f,28.0f,
+                                  29.0f,30.0f,31.0f,32.0f,
+                                  33.0f,34.0f,35.0f,36.0f);
+
+            float4x4 c = mul(a, b);
+            TestUtils.AreEqual(c.c0.x, 290.0f);
+            TestUtils.AreEqual(c.c1.x, 300.0f);
+            TestUtils.AreEqual(c.c2.x, 310.0f);
+            TestUtils.AreEqual(c.c3.x, 320.0f);
+
+            TestUtils.AreEqual(c.c0.y, 722.0f);
+            TestUtils.AreEqual(c.c1.y, 748.0f);
+            TestUtils.AreEqual(c.c2.y, 774.0f);
+            TestUtils.AreEqual(c.c3.y, 800.0f);
+
+            TestUtils.AreEqual(c.c0.z, 1154.0f);
+            TestUtils.AreEqual(c.c1.z, 1196.0f);
+            TestUtils.AreEqual(c.c2.z, 1238.0f);
+            TestUtils.AreEqual(c.c3.z, 1280.0f);
+
+            TestUtils.AreEqual(c.c0.w, 1586.0f);
+            TestUtils.AreEqual(c.c1.w, 1644.0f);
+            TestUtils.AreEqual(c.c2.w, 1702.0f);
+            TestUtils.AreEqual(c.c3.w, 1760.0f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_transpose()
+        {
+            float2x2 a = float2x2(1.0f, 2.0f,
+                                  3.0f, 4.0f);
+
+            float2x2 b = transpose(a);
+
+            TestUtils.AreEqual(b.c0.x, 1.0f);
+            TestUtils.AreEqual(b.c1.x, 3.0f);
+            TestUtils.AreEqual(b.c0.y, 2.0f);
+            TestUtils.AreEqual(b.c1.y, 4.0f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_transpose()
+        {
+            float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
+                                  4.0f, 5.0f, 6.0f,
+                                  7.0f, 8.0f, 9.0f);
+
+            float3x3 b = transpose(a);
+
+            TestUtils.AreEqual(b.c0.x, 1.0f);
+            TestUtils.AreEqual(b.c1.x, 4.0f);
+            TestUtils.AreEqual(b.c2.x, 7.0f);
+            TestUtils.AreEqual(b.c0.y, 2.0f);
+            TestUtils.AreEqual(b.c1.y, 5.0f);
+            TestUtils.AreEqual(b.c2.y, 8.0f);
+            TestUtils.AreEqual(b.c0.z, 3.0f);
+            TestUtils.AreEqual(b.c1.z, 6.0f);
+            TestUtils.AreEqual(b.c2.z, 9.0f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_transpose()
+        {
+            float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
+                                   5.0f,  6.0f,  7.0f,  8.0f,
+                                   9.0f, 10.0f, 11.0f, 12.0f,
+                                  13.0f, 14.0f, 15.0f, 16.0f);
+
+            float4x4 b = transpose(a);
+
+            TestUtils.AreEqual(b.c0.x, 1.0f);
+            TestUtils.AreEqual(b.c1.x, 5.0f);
+            TestUtils.AreEqual(b.c2.x, 9.0f);
+            TestUtils.AreEqual(b.c3.x, 13.0f);
+            TestUtils.AreEqual(b.c0.y, 2.0f);
+            TestUtils.AreEqual(b.c1.y, 6.0f);
+            TestUtils.AreEqual(b.c2.y, 10.0f);
+            TestUtils.AreEqual(b.c3.y, 14.0f);
+            TestUtils.AreEqual(b.c0.z, 3.0f);
+            TestUtils.AreEqual(b.c1.z, 7.0f);
+            TestUtils.AreEqual(b.c2.z, 11.0f);
+            TestUtils.AreEqual(b.c3.z, 15.0f);
+            TestUtils.AreEqual(b.c0.w, 4.0f);
+            TestUtils.AreEqual(b.c1.w, 8.0f);
+            TestUtils.AreEqual(b.c2.w, 12.0f);
+            TestUtils.AreEqual(b.c3.w, 16.0f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_inverse()
+        {
+            float2x2 a = float2x2( 0.542968f,  0.867379f,
+                                  -0.270153f, -0.912324f);
+
+            float2x2 invA = float2x2( 3.49499f,  3.32281f,
+                                     -1.03492f, -2.08004f);
+
+            float2x2 r = inverse(a);
+
+            float epsilon = 0.0001f;
+            TestUtils.AreEqual(invA.c0.x, r.c0.x, epsilon);
+            TestUtils.AreEqual(invA.c1.x, r.c1.x, epsilon);
+
+            TestUtils.AreEqual(invA.c0.y, r.c0.y, epsilon);
+            TestUtils.AreEqual(invA.c1.y, r.c1.y, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x3_inverse()
+        {
+            float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f,
+                                  -0.270153f,-0.912324f, 0.148933f,
+                                   0.816727f, 0.905933f, 0.902392f);
+
+            float3x3 invA = float3x3(-15.91790f,-5.077350f,10.1273f,
+                                       6.07051f, 0.994556f,-3.70676f,
+                                       8.31247f, 3.596890f,-4.33645f);
+
+            float3x3 r = inverse(a);
+
+            float epsilon = 0.0001f;
+            TestUtils.AreEqual(invA.c0.x, r.c0.x, epsilon);
+            TestUtils.AreEqual(invA.c1.x, r.c1.x, epsilon);
+            TestUtils.AreEqual(invA.c2.x, r.c2.x, epsilon);
+
+            TestUtils.AreEqual(invA.c0.y, r.c0.y, epsilon);
+            TestUtils.AreEqual(invA.c1.y, r.c1.y, epsilon);
+            TestUtils.AreEqual(invA.c2.y, r.c2.y, epsilon);
+
+            TestUtils.AreEqual(invA.c0.z, r.c0.z, epsilon);
+            TestUtils.AreEqual(invA.c1.z, r.c1.z, epsilon);
+            TestUtils.AreEqual(invA.c2.z, r.c2.z, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float4x4_inverse()
+        {
+            float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f,-0.943083f,
+                                  -0.270153f,-0.912324f, 0.148933f, 0.299995f,
+                                   0.816727f, 0.905933f, 0.902392f,-0.060931f,
+                                  -0.254780f, 0.604543f, 0.563340f,-0.383911f);
+
+            float4x4 invA = float4x4( 0.548951f, 0.126367f, 0.487260f,-1.327100f,
+                                     -0.582901f,-1.108000f, 0.188292f, 0.536211f,
+                                      0.001968f, 0.970678f, 0.528701f, 0.669759f,
+                                     -1.279310f,-0.404277f, 0.748937f, 0.103102f);
+
+            float4x4 r = inverse(a);
+
+            float epsilon = 0.0001f;
+            TestUtils.AreEqual(invA.c0.x, r.c0.x, epsilon);
+            TestUtils.AreEqual(invA.c1.x, r.c1.x, epsilon);
+            TestUtils.AreEqual(invA.c2.x, r.c2.x, epsilon);
+            TestUtils.AreEqual(invA.c3.x, r.c3.x, epsilon);
+
+            TestUtils.AreEqual(invA.c0.y, r.c0.y, epsilon);
+            TestUtils.AreEqual(invA.c1.y, r.c1.y, epsilon);
+            TestUtils.AreEqual(invA.c2.y, r.c2.y, epsilon);
+            TestUtils.AreEqual(invA.c3.y, r.c3.y, epsilon);
+
+            TestUtils.AreEqual(invA.c0.z, r.c0.z, epsilon);
+            TestUtils.AreEqual(invA.c1.z, r.c1.z, epsilon);
+            TestUtils.AreEqual(invA.c2.z, r.c2.z, epsilon);
+            TestUtils.AreEqual(invA.c3.z, r.c3.z, epsilon);
+
+            TestUtils.AreEqual(invA.c0.w, r.c0.w, epsilon);
+            TestUtils.AreEqual(invA.c1.w, r.c1.w, epsilon);
+            TestUtils.AreEqual(invA.c2.w, r.c2.w, epsilon);
+            TestUtils.AreEqual(invA.c3.w, r.c3.w, epsilon);
+        }
+
+        [TestCompiler]
+        public static void float3x4_fastinverse()
+        {
+            float4x4 a = test4x4_xyz;
+            a.c3 = float4(1, 2, 3, 1);
+
+            float3x4 b = float3x4(a.c0.xyz, a.c1.xyz, a.c2.xyz, a.c3.xyz);
+
+            float4x4 invA = inverse(a);
+            float3x4 fastInvB = fastinverse(b);
+
+            TestUtils.AreEqual(fastInvB.c0.xyz, invA.c0.xyz, 0.0001f);
+            TestUtils.AreEqual(fastInvB.c1.xyz, invA.c1.xyz, 0.0001f);
+            TestUtils.AreEqual(fastInvB.c2.xyz, invA.c2.xyz, 0.0001f);
+            TestUtils.AreEqual(fastInvB.c3.xyz, invA.c3.xyz, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_fastinverse()
+        {
+            float4x4 a = test4x4_xyz;
+            a.c3 = float4(1, 2, 3, 1);
+
+            float4x4 invA = inverse(a);
+            float4x4 fastInvA = fastinverse(a);
+
+            TestUtils.AreEqual(fastInvA, invA, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float2x2_determinant()
+        {
+            float2x2 a = float2x2(0.542968f, 0.867379f,
+                                  -0.270153f, -0.912324f);
+
+            float det = determinant(a);
+            TestUtils.AreEqual(det, -0.2610378f, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_determinant()
+        {
+            float3x3 a = float3x3( 0.542968f,  0.867379f, 0.526616f,
+                                  -0.270153f, -0.912324f, 0.148933f,
+                                   0.816727f,  0.905933f, 0.902392f);
+
+            float det = determinant(a);
+            TestUtils.AreEqual(det, 0.06019618f, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_determinant()
+        {
+            float4x4 a = float4x4( 0.542968f,  0.867379f, 0.526616f, -0.943083f,
+                                  -0.270153f, -0.912324f, 0.148933f,  0.299995f,
+                                   0.816727f,  0.905933f, 0.902392f, -0.060931f,
+                                  -0.254780f,  0.604543f, 0.563340f, -0.383911f);
+
+            float det = determinant(a);
+            TestUtils.AreEqual(det, 0.5838502f, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_look_rotation()
+        {
+            float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f));
+            float3 up0 = float3(0.0f, 1.0f, 0.0f);
+            float3x3 m0 = float3x3.LookRotation(forward0, up0);
+            TestUtils.AreEqual(m0,
+                float3x3( 0.948683f, -0.169031f, 0.267261f,
+                          0.000000f,  0.845154f, 0.534523f,
+                         -0.316228f, -0.507093f, 0.801784f), 0.001f);
+            TestUtils.AreEqual(m0, float3x3(quaternion.LookRotation(forward0, up0)), 0.001f);
+
+            float3 forward1 = normalize(float3(-3.2f, 2.3f, -1.3f));
+            float3 up1 = normalize(float3(1.0f, -3.2f, -1.5f));
+            float3x3 m1 = float3x3.LookRotation(forward1, up1);
+            TestUtils.AreEqual(m1,
+                float3x3( 0.605102f, -0.197976f, -0.771140f,
+                          0.485036f, -0.676417f,  0.554257f,
+                         -0.631342f, -0.709413f, -0.313276f), 0.001f);
+            TestUtils.AreEqual(m1, float3x3(quaternion.LookRotation(forward1, up1)), 0.001f);
+
+            float3 forward2 = normalize(float3(-2.6f, -5.2f, -1.1f));
+            float3 up2 = normalize(float3(-4.2f, -1.2f, -4.5f));
+            float3x3 m2 = float3x3.LookRotation(forward2, up2);
+            TestUtils.AreEqual(m2,
+                float3x3(-0.740918f, -0.507890f, -0.439418f,
+                          0.237577f,  0.413771f, -0.878835f,
+                          0.628170f, -0.755540f, -0.185907f), 0.001f);
+            TestUtils.AreEqual(m2, float3x3(quaternion.LookRotation(forward2, up2)), 0.001f);
+
+            float3 forward3 = normalize(float3(1.3f, 2.1f, 3.4f));
+            float3 up3 = normalize(float3(0.2f, -1.0f, 0.3f));
+            float3x3 m3 = float3x3.LookRotation(forward3, up3);
+            TestUtils.AreEqual(m3,
+                float3x3(-0.917727f,  0.249162f, 0.309349f,
+                         -0.066040f, -0.863668f, 0.499717f,
+                          0.391685f,  0.438174f, 0.809065f), 0.001f);
+            TestUtils.AreEqual(m3, float3x3(quaternion.LookRotation(forward3, up3)), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float3x3_look_rotation_safe()
+        {
+            float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
+            float3 up0 = float3(1.0f, -3.2f, -1.5f) * 1e10f;
+            float3x3 m0 = float3x3.LookRotationSafe(forward0, up0);
+            TestUtils.AreEqual(m0,
+                float3x3(0.605102f, -0.197976f, -0.771140f,
+                          0.485036f, -0.676417f, 0.554257f,
+                         -0.631342f, -0.709413f, -0.313276f), 0.001f);
+
+            float3 forward1 = float3(-3.2f, 2.3f, -1.3f) * 1e-30f;
+            float3 up1 = float3(1.0f, -3.2f, -1.5f);
+            float3x3 m1 = float3x3.LookRotationSafe(forward1, up1);
+            TestUtils.AreEqual(m1, float3x3.identity, 0.001f);
+        }
+
+
+        [TestCompiler]
+        public static void float4x4_lookat()
+        {
+            float4x4 m = float4x4.LookAt(float3(0.3f, -0.5f, 3.0f), float3(3.2f, -3.1f, 0.2f), normalize(float3(0.3f, 1.0f, -3.0f)));
+            float4x4 r = float4x4(
+                -0.77374f, -0.18930f,  0.60456f,  0.30000f,
+                -0.57373f,  0.61404f, -0.54202f, -0.50000f,
+                -0.26862f, -0.76624f, -0.58371f,  3.00000f,
+                 0.00000f,  0.00000f,  0.00000f,  1.00000f
+                );
+            TestUtils.AreEqual(m, r, 0.001f);
+        }
+
+
+        [TestCompiler]
+        public static void float4x4_ortho()
+        {
+            float4x4 m = float4x4.Ortho(2.0f, 3.0f, -3.0f, 7.0f);
+            float4x4 r = float4x4(
+                1.00000f, 0.00000f,  0.00000f,  0.00000f,
+                0.00000f, 0.66667f,  0.00000f,  0.00000f,
+                0.00000f, 0.00000f, -0.20000f, -0.40000f,
+                0.00000f, 0.00000f,  0.00000f,  1.00000f
+                );
+            TestUtils.AreEqual(m, r, 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_orthoOffCenter()
+        {
+            float4x4 m = float4x4.OrthoOffCenter(-2.0f, 1.0f, -3.0f, -1.0f, -3.0f, 7.0f);
+            float4x4 r = float4x4(
+                0.66667f, 0.00000f,  0.00000f,  0.33333f,
+                0.00000f, 1.00000f,  0.00000f,  2.00000f,
+                0.00000f, 0.00000f, -0.20000f, -0.40000f,
+                0.00000f, 0.00000f,  0.00000f,  1.00000f
+                );
+            TestUtils.AreEqual(m, r, 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_perspective()
+        {
+            float fovy = 1.6f;
+            float aspect = 1.3333f;
+            float near = 0.1f;
+            float far = 100.0f;
+
+            float height = tan(fovy * 0.5f) * near;
+            float width = height * 1.3333f;
+
+            float4x4 m = float4x4.PerspectiveFov(fovy, aspect, near, far);
+            float4x4 r = float4x4(
+                0.72843f, 0.00000f,  0.00000f,  0.00000f,
+                0.00000f, 0.97121f,  0.00000f,  0.00000f,
+                0.00000f, 0.00000f, -1.00200f, -0.20020f,
+                0.00000f, 0.00000f, -1.00000f,  0.00000f
+                );
+            TestUtils.AreEqual(m, r, 0.001f);
+
+            float4 p0 = mul(m, float4(-width, -height, -near, 1.0f));
+            float4 pp0 = p0 / p0.w;
+            TestUtils.AreEqual(pp0.xyz, float3(-1.0f, -1.0f, -1.0f), 0.001f);
+
+            float4 p1 = mul(m, float4(width / near * far, height / near * far, -far, 1.0f));
+            float4 pp1 = p1 / p1.w;
+            TestUtils.AreEqual(pp1.xyz, float3(1.0f, 1.0f, 1.0f), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_perspectiveOffCenter()
+        {
+            float fovy = 1.6f;
+            float aspect = 1.3333f;
+            float near = 0.1f;
+            float far = 100.0f;
+            
+            float4x4 r0 = float4x4.PerspectiveFov(fovy, aspect, near, far);
+
+            float height = tan(fovy * 0.5f) * near;
+            float width = height * 1.3333f;
+
+            float4x4 m0 = float4x4.PerspectiveOffCenter(-width, width, -height, height, 0.1f, 100.0f);
+            TestUtils.AreEqual(m0, r0, 0.001f);
+            
+            float left = -0.3f;
+            float right = -0.1f;
+            float bottom = -0.2f;
+            float top = 0.1f;
+            float4x4 m1 = float4x4.PerspectiveOffCenter(left, right, bottom, top, near, far);
+            float4 p0 = mul(m1, float4(left, bottom, -near, 1.0f));
+            float4 pp0 = p0 / p0.w;
+            TestUtils.AreEqual(pp0.xyz, float3(-1.0f, -1.0f, -1.0f), 0.001f);
+
+            float4 p1 = mul(m1, float4(right, top, -near, 1.0f));
+            float4 pp1 = p1 / p1.w;
+            TestUtils.AreEqual(pp1.xyz, float3(1.0f, 1.0f, -1.0f), 0.001f);
+
+            float4 p2 = mul(m1, float4(left*far/near, top * far / near, -far, 1.0f));
+            float4 pp2 = p2 / p2.w;
+            TestUtils.AreEqual(pp2.xyz, float3(-1.0f,  1.0f, 1.0f), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void float4x4_TRS()
+        {
+            float3 scale = float3(1.2f, -0.4f, 2.3f);
+            quaternion rotation = TestQuaternion.test_q0;
+            float3 translation = float3(12.3f, -4.3f, 135.99f);
+            float4x4 r0 = mul(float4x4(quaternion.identity, translation), mul(float4x4(rotation, float3.zero), float4x4.Scale(scale)));
+            float4x4 m0 = float4x4.TRS(translation, rotation, scale);
+            TestUtils.AreEqual(m0, r0, 0.001f);
+        }
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5e1f1b32e36beecf4fbbffa6eae61a60885bd4d1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestMatrix.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6216aa8a60396374dbab4fbd185eac26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5de441748358d813aca9277454fffd51b4ac69a1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs
@@ -0,0 +1,341 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    class TestQuaternion
+    {
+        [TestCompiler]
+        public static void quaternion_basic_constructors()
+        {
+            quaternion q = quaternion(1.0f, 2.0f, 3.0f, 4.0f);
+            quaternion q2 = quaternion(float4(1.0f, 2.0f, 3.0f, 4.0f));
+
+            TestUtils.AreEqual(q.value.x, 1.0f);
+            TestUtils.AreEqual(q.value.y, 2.0f);
+            TestUtils.AreEqual(q.value.z, 3.0f);
+            TestUtils.AreEqual(q.value.w, 4.0f);
+            TestUtils.AreEqual(q2.value.x, 1.0f);
+            TestUtils.AreEqual(q2.value.y, 2.0f);
+            TestUtils.AreEqual(q2.value.z, 3.0f);
+            TestUtils.AreEqual(q2.value.w, 4.0f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_construct_from_matrix()
+        {
+            TestUtils.AreEqual(TestMatrix.test3x3_xyz, float3x3(quaternion(TestMatrix.test3x3_xyz)), 0.0001f);
+            TestUtils.AreEqual(TestMatrix.test4x4_xyz, float4x4(quaternion(TestMatrix.test4x4_xyz), float3.zero), 0.0001f);
+
+            // Make sure to hit all 4 cases
+            float3x3 m0 = float3x3.AxisAngle(normalize(float3(1, 2, 3)), 1.0f);
+            float3x3 m1 = float3x3.AxisAngle(normalize(float3(3, 2, 1)), 3.0f);
+            float3x3 m2 = float3x3.AxisAngle(normalize(float3(1, 3, 2)), 3.0f);
+            float3x3 m3 = float3x3.AxisAngle(normalize(float3(1, 2, 3)), 3.0f);
+            quaternion q0 = quaternion(m0);
+            quaternion q1 = quaternion(m1);
+            quaternion q2 = quaternion(m2);
+            quaternion q3 = quaternion(m3);
+            TestUtils.AreEqual(q0, quaternion(0.1281319f, 0.2562638f, 0.3843956f, 0.8775827f), 0.0001f);
+            TestUtils.AreEqual(q1, quaternion(0.7997754f, 0.5331835f, 0.2665918f, 0.0707372f), 0.0001f);
+            TestUtils.AreEqual(q2, quaternion(0.2665918f, 0.7997754f, 0.5331835f, 0.0707372f), 0.0001f);
+            TestUtils.AreEqual(q3, quaternion(0.2665918f, 0.5331835f, 0.7997754f, 0.0707372f), 0.0001f);
+        }
+
+
+        [TestCompiler]
+        public static void quaternion_construct_from_matrix3x3_torture()
+        {
+            Random rnd = new Random(0x12345678);
+            for(int i = 0; i < 1000; i++)
+            {
+                float3x3 r = float3x3(rnd.NextQuaternionRotation());
+                quaternion q = quaternion(r);
+                float3x3 t = float3x3(q);
+                TestUtils.AreEqual(t, r, 0.001f);
+            }
+        }
+
+        [TestCompiler]
+        public static void quaternion_construct_from_matrix4x4_torture()
+        {
+            Random rnd = new Random(0x12345678);
+            for (int i = 0; i < 1000; i++)
+            {
+                float4x4 r = float4x4(rnd.NextQuaternionRotation(), float3.zero);
+                quaternion q = quaternion(r);
+                float4x4 t = float4x4(q, float3.zero);
+                TestUtils.AreEqual(t, r, 0.001f);
+            }
+        }
+
+        [TestCompiler]
+        public static void quaternion_axis_angle()
+        {
+            quaternion q = quaternion.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
+
+            quaternion r = quaternion(-0.2562833f, -0.5125666f, -0.76885f, 0.2836622f);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_axis_angle_consistency()
+        {
+            TestUtils.AreEqual(quaternion.AxisAngle(float3(1, 0, 0), 1.0f), quaternion.RotateX(1.0f), 0.001f);
+            TestUtils.AreEqual(quaternion.AxisAngle(float3(0, 1, 0), 1.0f), quaternion.RotateY(1.0f), 0.001f);
+            TestUtils.AreEqual(quaternion.AxisAngle(float3(0, 0, 1), 1.0f), quaternion.RotateZ(1.0f), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_euler()
+        {
+            float3 test_angles = TestMatrix.test_angles;
+            quaternion q0 = quaternion.Euler(test_angles);
+            quaternion q0_xyz = quaternion.Euler(test_angles, RotationOrder.XYZ);
+            quaternion q0_xzy = quaternion.Euler(test_angles, RotationOrder.XZY);
+            quaternion q0_yxz = quaternion.Euler(test_angles, RotationOrder.YXZ);
+            quaternion q0_yzx = quaternion.Euler(test_angles, RotationOrder.YZX);
+            quaternion q0_zxy = quaternion.Euler(test_angles, RotationOrder.ZXY);
+            quaternion q0_zyx = quaternion.Euler(test_angles, RotationOrder.ZYX);
+
+            quaternion q1 = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z);
+            quaternion q1_xyz = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XYZ);
+            quaternion q1_xzy = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XZY);
+            quaternion q1_yxz = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YXZ);
+            quaternion q1_yzx = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YZX);
+            quaternion q1_zxy = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZXY);
+            quaternion q1_zyx = quaternion.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZYX);
+
+            float epsilon = 0.0001f;
+            TestUtils.AreEqual(q0, quaternion(-0.3133549f, 0.3435619f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q0_xyz, quaternion(-0.4597331f, 0.06979711f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q0_xzy, quaternion(-0.3133549f, 0.06979711f, 0.3899215f, 0.8630749f), epsilon);
+            TestUtils.AreEqual(q0_yxz, quaternion(-0.4597331f, 0.06979711f, 0.1971690f, 0.8630748f), epsilon);
+            TestUtils.AreEqual(q0_yzx, quaternion(-0.4597331f, 0.34356190f, 0.1971690f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q0_zxy, quaternion(-0.3133549f, 0.34356190f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q0_zyx, quaternion(-0.3133549f, 0.34356190f, 0.1971690f, 0.8630749f), epsilon);
+
+            TestUtils.AreEqual(q1, quaternion(-0.3133549f, 0.3435619f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q1_xyz, quaternion(-0.4597331f, 0.06979711f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q1_xzy, quaternion(-0.3133549f, 0.06979711f, 0.3899215f, 0.8630749f), epsilon);
+            TestUtils.AreEqual(q1_yxz, quaternion(-0.4597331f, 0.06979711f, 0.1971690f, 0.8630748f), epsilon);
+            TestUtils.AreEqual(q1_yzx, quaternion(-0.4597331f, 0.34356190f, 0.1971690f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q1_zxy, quaternion(-0.3133549f, 0.34356190f, 0.3899215f, 0.7948176f), epsilon);
+            TestUtils.AreEqual(q1_zyx, quaternion(-0.3133549f, 0.34356190f, 0.1971690f, 0.8630749f), epsilon);
+
+            float3x3 m0 = float3x3(q0);
+            float3x3 m0_xyz = float3x3(q0_xyz);
+            float3x3 m0_xzy = float3x3(q0_xzy);
+            float3x3 m0_yxz = float3x3(q0_yxz);
+            float3x3 m0_yzx = float3x3(q0_yzx);
+            float3x3 m0_zxy = float3x3(q0_zxy);
+            float3x3 m0_zyx = float3x3(q0_zyx);
+
+            float3x3 m1 = float3x3(q1);
+            float3x3 m1_xyz = float3x3(q1_xyz);
+            float3x3 m1_xzy = float3x3(q1_xzy);
+            float3x3 m1_yxz = float3x3(q1_yxz);
+            float3x3 m1_yzx = float3x3(q1_yzx);
+            float3x3 m1_zxy = float3x3(q1_zxy);
+            float3x3 m1_zyx = float3x3(q1_zyx);
+
+            TestUtils.AreEqual(m0, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m0_xyz, TestMatrix.test3x3_xyz, epsilon);
+            TestUtils.AreEqual(m0_yzx, TestMatrix.test3x3_yzx, epsilon);
+            TestUtils.AreEqual(m0_zxy, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m0_xzy, TestMatrix.test3x3_xzy, epsilon);
+            TestUtils.AreEqual(m0_yxz, TestMatrix.test3x3_yxz, epsilon);
+            TestUtils.AreEqual(m0_zyx, TestMatrix.test3x3_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m1, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m1_xyz, TestMatrix.test3x3_xyz, epsilon);
+            TestUtils.AreEqual(m1_yzx, TestMatrix.test3x3_yzx, epsilon);
+            TestUtils.AreEqual(m1_zxy, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m1_xzy, TestMatrix.test3x3_xzy, epsilon);
+            TestUtils.AreEqual(m1_yxz, TestMatrix.test3x3_yxz, epsilon);
+            TestUtils.AreEqual(m1_zyx, TestMatrix.test3x3_zyx, epsilon);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotateX()
+        {
+            float angle = 2.3f;
+            quaternion q = quaternion.RotateX(angle);
+
+            quaternion r = quaternion(0.91276394f, 0.0f, 0.0f, 0.40848744f);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotateY()
+        {
+            float angle = 2.3f;
+            quaternion q = quaternion.RotateY(angle);
+
+            quaternion r = quaternion(0.0f, 0.91276394f, 0.0f, 0.40848744f);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotateZ()
+        {
+            float angle = 2.3f;
+            quaternion q = quaternion.RotateZ(angle);
+
+            quaternion r = quaternion(0.0f, 0.0f, 0.91276394f, 0.40848744f);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        static internal readonly quaternion test_q0 = new quaternion(0.3270836f, 0.8449658f, -0.1090279f, 0.4088545f);
+        static internal readonly quaternion test_q1 = new quaternion(-0.05623216f, 0.731018f, -0.6747859f, -0.08434824f);
+        static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
+        static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
+
+        [TestCompiler]
+        public static void quaternion_conjugate()
+        {
+            quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
+            quaternion cq = conjugate(q);
+            quaternion r = quaternion(-1.0f, 2.0f, -3.0f, -4.0f);
+
+            TestUtils.AreEqual(cq, r);
+        }
+
+        [TestCompiler]
+        public static void quaternion_inverse()
+        {
+            quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
+            quaternion iq = inverse(q);
+            quaternion qiq = mul(iq, q);
+
+            TestUtils.AreEqual(qiq, quaternion.identity, 0.00001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_dot()
+        {
+            float dot01 = dot(test_q0, test_q1);
+            float dot02 = dot(test_q0, test_q2);
+
+            TestUtils.AreEqual(dot01,  0.6383769f, 0.00001f);
+            TestUtils.AreEqual(dot02, -0.5795583f, 0.00001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_nlerp()
+        {
+            quaternion r0 = nlerp(test_q0, test_q1, 0.3f);
+            quaternion r1 = nlerp(test_q0, test_q1, -4.3f);
+            quaternion r2 = nlerp(test_q0, test_q1, 5.1f);
+
+            TestUtils.AreEqual(r0, quaternion(0.2302977f, 0.8803911f, -0.3026878f, 0.2832927f), 0.0001f);
+            TestUtils.AreEqual(r1, quaternion(0.4724294f, 0.3192692f, 0.5557517f, 0.604994f), 0.0001f);
+            TestUtils.AreEqual(r2, quaternion(-0.4054004f, 0.06570576f, -0.7457358f, -0.5246059f), 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_slerp()
+        {
+            quaternion r0 = slerp(test_q0, test_q1, 0.3f);
+            quaternion r1 = slerp(test_q0, test_q1, -4.3f);
+            quaternion r2 = slerp(test_q0, test_q1, 5.1f);
+
+            TestUtils.AreEqual(r0, quaternion(0.2261014f, 0.8806396f, -0.3100654f, 0.2778693f), 0.0001f);
+            TestUtils.AreEqual(r1, quaternion(-0.4676181f, -0.5321988f, -0.3789966f, -0.5953646f), 0.0001f);
+            TestUtils.AreEqual(r2, quaternion(0.2596942f, -0.4369303f, 0.7902023f, 0.34239f), 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_mul_vector()
+        {
+            float3x3 m = TestMatrix.test3x3_xyz;
+            quaternion q = quaternion(m);
+
+            float3 vector = float3(1.1f, -2.2f, 3.5f);
+
+            float3 mvector = mul(m, vector);
+            float3 qvector = mul(q, vector);
+
+            TestUtils.AreEqual(qvector, mvector, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_log_exp_identity()
+        {
+            quaternion q = quaternion(1.2f, -2.6f, 3.1f, 6.0f);
+            quaternion log_q = log(q);
+            quaternion exp_log_q = exp(log_q);
+            TestUtils.AreEqual(exp_log_q, q, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_log_exp_rotation()
+        {
+            quaternion q = quaternion(TestMatrix.test3x3_xyz);
+            quaternion q3 = mul(q, mul(q, q));
+            quaternion log_q = log(q);
+            quaternion t = exp(quaternion(log_q.value * 3.0f));
+            TestUtils.AreEqual(t, q3, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_unitlog_unitexp_rotation()
+        {
+            quaternion q = quaternion(TestMatrix.test3x3_xyz);
+            quaternion q3 = mul(q, mul(q, q));
+            quaternion log_q = unitlog(q);
+            quaternion t = unitexp(quaternion(log_q.value * 3.0f));
+            TestUtils.AreEqual(t, q3, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_look_rotation()
+        {
+            // Exercise the 4 cases
+            float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f));
+            float3 up0 = float3(0.0f, 1.0f, 0.0f);
+            quaternion q0 = quaternion.LookRotation(forward0, up0);
+            TestUtils.AreEqual(q0, quaternion(-0.274657f, 0.153857f, 0.044571f, 0.948106f), 0.001f);
+            TestUtils.AreEqual(float3x3(q0), float3x3.LookRotation(forward0, up0), 0.001f);
+
+            float3 forward1 = normalize(float3(-3.2f, 2.3f, -1.3f));
+            float3 up1 = normalize(float3(1.0f, -3.2f, -1.5f));
+            quaternion q1 = quaternion.LookRotation(forward1, up1);
+            TestUtils.AreEqual(q1, quaternion(0.805418f, 0.089103f, -0.435327f, -0.392240f), 0.001f);
+            TestUtils.AreEqual(float3x3(q1), float3x3.LookRotation(forward1, up1), 0.001f);
+
+            float3 forward2 = normalize(float3(-2.6f, -5.2f, -1.1f));
+            float3 up2 = normalize(float3(-4.2f, -1.2f, -4.5f));
+            quaternion q2 = quaternion.LookRotation(forward2, up2);
+            TestUtils.AreEqual(q2, quaternion(-0.088343f, 0.764951f, -0.534144f, -0.348907f), 0.001f);
+            TestUtils.AreEqual(float3x3(q2), float3x3.LookRotation(forward2, up2), 0.001f);
+
+            float3 forward3 = normalize(float3(1.3f, 2.1f, 3.4f));
+            float3 up3 = normalize(float3(0.2f, -1.0f, 0.3f));
+            quaternion q3 = quaternion.LookRotation(forward3, up3);
+            TestUtils.AreEqual(q3, quaternion(0.184984f, 0.247484f, 0.947425f, -0.083173f), 0.001f);
+            TestUtils.AreEqual(float3x3(q3), float3x3.LookRotation(forward3, up3), 0.001f);
+        }
+
+        [TestCompiler]
+        public static void quaternion_look_rotation_safe()
+        {
+            float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
+            float3 up0 = float3(1.0f, -3.2f, -1.5f) * 1e10f;
+            quaternion q0 = quaternion.LookRotationSafe(forward0, up0);
+            TestUtils.AreEqual(q0, quaternion(0.805418f, 0.089103f, -0.435327f, -0.392240f), 0.001f);
+
+            float3 forward1 = float3(-3.2f, 2.3f, -1.3f) * 1e-30f;
+            float3 up1 = float3(1.0f, -3.2f, -1.5f);
+            quaternion q1 = quaternion.LookRotationSafe(forward1, up1);
+            TestUtils.AreEqual(q1, quaternion.identity, 0.001f);
+
+            float3 forward2 = float3(-3.2f, 2.3f, -1.3f);
+            float3 up2 = forward2;
+            quaternion q2 = quaternion.LookRotationSafe(forward2, up2);
+            TestUtils.AreEqual(q2, quaternion.identity, 0.001f);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..9ea60bc5b3a20de811f99b8e78a7f7c5c8cbb180
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestQuaternion.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 36c7224b1052973439eead9de857ea33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs
new file mode 100644
index 0000000000000000000000000000000000000000..5255b652bc4e582f770d522bb45a348175f99e7d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs
@@ -0,0 +1,163 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    class TestRigidTransform
+    {
+        [TestCompiler]
+        public static void rigid_transform_construct_from_matrix()
+        {
+            float4x4 m4x4 = TestMatrix.test4x4_zyx;
+
+            RigidTransform q4x4 = RigidTransform(m4x4);
+
+            float4x4 mq4x4 = float4x4(q4x4);
+
+            TestUtils.AreEqual(mq4x4, m4x4, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void rigid_transform_axisAngle()
+        {
+            RigidTransform q = RigidTransform.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
+
+            RigidTransform r = RigidTransform(quaternion(-0.2562833f, -0.5125666f, -0.76885f, 0.2836622f), float3.zero);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void rigid_transform_euler()
+        {
+            float3 test_angles = TestMatrix.test_angles;
+            RigidTransform q0 = RigidTransform.Euler(test_angles);
+            RigidTransform q0_xyz = RigidTransform.Euler(test_angles, RotationOrder.XYZ);
+            RigidTransform q0_xzy = RigidTransform.Euler(test_angles, RotationOrder.XZY);
+            RigidTransform q0_yxz = RigidTransform.Euler(test_angles, RotationOrder.YXZ);
+            RigidTransform q0_yzx = RigidTransform.Euler(test_angles, RotationOrder.YZX);
+            RigidTransform q0_zxy = RigidTransform.Euler(test_angles, RotationOrder.ZXY);
+            RigidTransform q0_zyx = RigidTransform.Euler(test_angles, RotationOrder.ZYX);
+
+            RigidTransform q1 = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z);
+            RigidTransform q1_xyz = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XYZ);
+            RigidTransform q1_xzy = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.XZY);
+            RigidTransform q1_yxz = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YXZ);
+            RigidTransform q1_yzx = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.YZX);
+            RigidTransform q1_zxy = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZXY);
+            RigidTransform q1_zyx = RigidTransform.Euler(test_angles.x, test_angles.y, test_angles.z, RotationOrder.ZYX);
+
+            float epsilon = 0.0001f;
+            TestUtils.AreEqual(q0, RigidTransform(quaternion(-0.3133549f, 0.3435619f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_xyz, RigidTransform(quaternion(-0.4597331f, 0.06979711f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_xzy, RigidTransform(quaternion(-0.3133549f, 0.06979711f, 0.3899215f, 0.8630749f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_yxz, RigidTransform(quaternion(-0.4597331f, 0.06979711f, 0.1971690f, 0.8630748f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_yzx, RigidTransform(quaternion(-0.4597331f, 0.34356190f, 0.1971690f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_zxy, RigidTransform(quaternion(-0.3133549f, 0.34356190f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q0_zyx, RigidTransform(quaternion(-0.3133549f, 0.34356190f, 0.1971690f, 0.8630749f), float3.zero), epsilon);
+
+            TestUtils.AreEqual(q1, RigidTransform(quaternion(-0.3133549f, 0.3435619f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_xyz, RigidTransform(quaternion(-0.4597331f, 0.06979711f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_xzy, RigidTransform(quaternion(-0.3133549f, 0.06979711f, 0.3899215f, 0.8630749f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_yxz, RigidTransform(quaternion(-0.4597331f, 0.06979711f, 0.1971690f, 0.8630748f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_yzx, RigidTransform(quaternion(-0.4597331f, 0.34356190f, 0.1971690f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_zxy, RigidTransform(quaternion(-0.3133549f, 0.34356190f, 0.3899215f, 0.7948176f), float3.zero), epsilon);
+            TestUtils.AreEqual(q1_zyx, RigidTransform(quaternion(-0.3133549f, 0.34356190f, 0.1971690f, 0.8630749f), float3.zero), epsilon);
+
+            float3x3 m0 = float3x3(q0.rot);
+            float3x3 m0_xyz = float3x3(q0_xyz.rot);
+            float3x3 m0_xzy = float3x3(q0_xzy.rot);
+            float3x3 m0_yxz = float3x3(q0_yxz.rot);
+            float3x3 m0_yzx = float3x3(q0_yzx.rot);
+            float3x3 m0_zxy = float3x3(q0_zxy.rot);
+            float3x3 m0_zyx = float3x3(q0_zyx.rot);
+
+            float3x3 m1 = float3x3(q1.rot);
+            float3x3 m1_xyz = float3x3(q1_xyz.rot);
+            float3x3 m1_xzy = float3x3(q1_xzy.rot);
+            float3x3 m1_yxz = float3x3(q1_yxz.rot);
+            float3x3 m1_yzx = float3x3(q1_yzx.rot);
+            float3x3 m1_zxy = float3x3(q1_zxy.rot);
+            float3x3 m1_zyx = float3x3(q1_zyx.rot);
+
+            TestUtils.AreEqual(m0, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m0_xyz, TestMatrix.test3x3_xyz, epsilon);
+            TestUtils.AreEqual(m0_yzx, TestMatrix.test3x3_yzx, epsilon);
+            TestUtils.AreEqual(m0_zxy, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m0_xzy, TestMatrix.test3x3_xzy, epsilon);
+            TestUtils.AreEqual(m0_yxz, TestMatrix.test3x3_yxz, epsilon);
+            TestUtils.AreEqual(m0_zyx, TestMatrix.test3x3_zyx, 0.0001f);
+
+            TestUtils.AreEqual(m1, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m1_xyz, TestMatrix.test3x3_xyz, epsilon);
+            TestUtils.AreEqual(m1_yzx, TestMatrix.test3x3_yzx, epsilon);
+            TestUtils.AreEqual(m1_zxy, TestMatrix.test3x3_zxy, epsilon);
+            TestUtils.AreEqual(m1_xzy, TestMatrix.test3x3_xzy, epsilon);
+            TestUtils.AreEqual(m1_yxz, TestMatrix.test3x3_yxz, epsilon);
+            TestUtils.AreEqual(m1_zyx, TestMatrix.test3x3_zyx, epsilon);
+        }
+
+        [TestCompiler]
+        public static void rigid_transform_rotateX()
+        {
+            float angle = 2.3f;
+            RigidTransform q = RigidTransform.RotateX(angle);
+
+            RigidTransform r = RigidTransform(quaternion(0.91276394f, 0.0f, 0.0f, 0.40848744f), float3.zero);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void rigid_transform_rotateY()
+        {
+            float angle = 2.3f;
+            RigidTransform q = RigidTransform.RotateY(angle);
+
+            RigidTransform r = RigidTransform(quaternion(0.0f, 0.91276394f, 0.0f, 0.40848744f), float3.zero);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void rigid_transform_rotateZ()
+        {
+            float angle = 2.3f;
+            RigidTransform q = RigidTransform.RotateZ(angle);
+
+            RigidTransform r = RigidTransform(quaternion(0.0f, 0.0f, 0.91276394f, 0.40848744f), float3.zero);
+            TestUtils.AreEqual(q, r, 0.0001f);
+        }
+
+        static internal readonly quaternion test_q0 = new quaternion(0.3270836f, 0.8449658f, -0.1090279f, 0.4088545f);
+        static internal readonly quaternion test_q1 = new quaternion(-0.05623216f, 0.731018f, -0.6747859f, -0.08434824f);
+        static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
+        static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
+        
+        [TestCompiler]
+        public static void rigid_transform_inverse()
+        {
+            RigidTransform q = RigidTransform(quaternion(1.0f, -2.0f, 3.0f, -4.0f), float3(1,2,3));
+            RigidTransform iq = inverse(q);
+            RigidTransform qiq = mul(iq, q);
+
+            TestUtils.AreEqual(qiq, RigidTransform.identity, 0.00001f);
+        }
+        
+        [TestCompiler]
+        public static void rigid_transform_mul_vector()
+        {
+            float4x4 m = TestMatrix.test4x4_xyz;
+            RigidTransform q = RigidTransform(m);
+
+            float3 vector = float3(1.1f, -2.2f, 3.5f);
+
+            float4 mvector0 = mul(m, float4(vector, 0));
+            float4 qvector0 = mul(q, float4(vector, 0));
+            TestUtils.AreEqual(qvector0, mvector0, 0.0001f);
+
+            float4 mvector1 = mul(m, float4(vector, 1));
+            float4 qvector1 = mul(q, float4(vector, 1));
+            TestUtils.AreEqual(qvector1, mvector1, 0.0001f);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..2d5869d657c0d41ffa21ec5c08cbbd0fe3e5bcaa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestRigidTransform.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0ea7743c8ecbfba4abe11751b744207e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c926e8d1b1f25db29da832360bb5e8140d1b8bc6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs
@@ -0,0 +1,1339 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint2
+    {
+        [TestCompiler]
+        public static void uint2_zero()
+        {
+            TestUtils.AreEqual(uint2.zero.x, 0u);
+            TestUtils.AreEqual(uint2.zero.y, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint2_constructor()
+        {
+            uint2 a = new uint2(1, 2);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+        }
+
+        [TestCompiler]
+        public static void uint2_scalar_constructor()
+        {
+            uint2 a = new uint2(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint2_static_constructor()
+        {
+            uint2 a = uint2(1, 2);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+        }
+
+        [TestCompiler]
+        public static void uint2_static_scalar_constructor()
+        {
+            uint2 a = uint2(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_equal_wide_wide()
+        {
+            uint2 a0 = uint2(790229414, 970783976);
+            uint2 b0 = uint2(612337669, 1214209108);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2 a1 = uint2(1428432738, 1578747135);
+            uint2 b1 = uint2(2120643427, 295461214);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2 a2 = uint2(1733797753, 2001507228);
+            uint2 b2 = uint2(1510890331, 1893316566);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2 a3 = uint2(1446876437, 1777406370);
+            uint2 b3 = uint2(921816149, 1834958575);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_equal_wide_scalar()
+        {
+            uint2 a0 = uint2(1211464300, 1921862607);
+            uint b0 = (746972502);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2 a1 = uint2(508076684, 1394594555);
+            uint b1 = (1249127920);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2 a2 = uint2(746862310, 1884008277);
+            uint b2 = (1733655277);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2 a3 = uint2(1682018538, 936027116);
+            uint b3 = (795585660);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint2 b0 = uint2(233855098, 924242519);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1402948791);
+            uint2 b1 = uint2(601381975, 2120518068);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (629187703);
+            uint2 b2 = uint2(1971977031, 47183124);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1061805787);
+            uint2 b3 = uint2(1009011238, 312511148);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_not_equal_wide_wide()
+        {
+            uint2 a0 = uint2(1660932106, 982847023);
+            uint2 b0 = uint2(107139049, 75478496);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2 a1 = uint2(97046264, 1739517447);
+            uint2 b1 = uint2(2055495054, 358586687);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2 a2 = uint2(1253499180, 1830584069);
+            uint2 b2 = uint2(942338347, 111564990);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2 a3 = uint2(1841470429, 1397841646);
+            uint2 b3 = uint2(113811950, 948912488);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_not_equal_wide_scalar()
+        {
+            uint2 a0 = uint2(747758183, 1033001286);
+            uint b0 = (248693828);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2 a1 = uint2(1439973882, 1197845089);
+            uint b1 = (2138928797);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2 a2 = uint2(1432672459, 238704450);
+            uint b2 = (950170763);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2 a3 = uint2(2105962247, 1640688041);
+            uint b3 = (727205263);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint2 b0 = uint2(2037494727, 1989050616);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (48833929);
+            uint2 b1 = uint2(1897435904, 514354517);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (1783749164);
+            uint2 b2 = uint2(364694471, 754315072);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (124108032);
+            uint2 b3 = uint2(1512967900, 1178825850);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_wide_wide()
+        {
+            uint2 a0 = uint2(1182186063, 415538999);
+            uint2 b0 = uint2(524633529, 1032195686);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2 a1 = uint2(1667335818, 1566618442);
+            uint2 b1 = uint2(760723389, 1505751409);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2 a2 = uint2(1166180837, 639095188);
+            uint2 b2 = uint2(431962172, 1287906509);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2 a3 = uint2(1080836365, 771119973);
+            uint2 b3 = uint2(1560084663, 1450178202);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_wide_scalar()
+        {
+            uint2 a0 = uint2(608447185, 818840405);
+            uint b0 = (1491216667);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2 a1 = uint2(869219329, 1214500548);
+            uint b1 = (2080125385);
+            bool2 r1 = bool2(true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2 a2 = uint2(1361741203, 1615392341);
+            uint b2 = (1667165786);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2 a3 = uint2(840091491, 1247103789);
+            uint b3 = (469591900);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint2 b0 = uint2(282703327, 14370648);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1862117300);
+            uint2 b1 = uint2(1304793311, 826073259);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (988910157);
+            uint2 b2 = uint2(445132446, 1139670255);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (111349251);
+            uint2 b3 = uint2(1102440676, 112183144);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_wide_wide()
+        {
+            uint2 a0 = uint2(592884447, 2133928932);
+            uint2 b0 = uint2(138737040, 192863971);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2 a1 = uint2(918957182, 1284069471);
+            uint2 b1 = uint2(1700841444, 1044631301);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2 a2 = uint2(194584707, 739120780);
+            uint2 b2 = uint2(1391589821, 730837695);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2 a3 = uint2(241654068, 1340158550);
+            uint2 b3 = uint2(253553987, 2078872742);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_wide_scalar()
+        {
+            uint2 a0 = uint2(1097138316, 211763648);
+            uint b0 = (438688675);
+            bool2 r0 = bool2(true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2 a1 = uint2(1883002501, 43662641);
+            uint b1 = (56406996);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2 a2 = uint2(1923456111, 1219010035);
+            uint b2 = (1437755186);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2 a3 = uint2(2125058448, 893125636);
+            uint b3 = (304028799);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint2 b0 = uint2(599356784, 185671342);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1932327391);
+            uint2 b1 = uint2(2025591013, 1257191721);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1312388500);
+            uint2 b2 = uint2(1443698859, 779217735);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (691047512);
+            uint2 b3 = uint2(741776730, 732565983);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_equal_wide_wide()
+        {
+            uint2 a0 = uint2(1577248162, 2043073061);
+            uint2 b0 = uint2(903445031, 2108974565);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2 a1 = uint2(1688380407, 176431985);
+            uint2 b1 = uint2(210822256, 1281704747);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2 a2 = uint2(223299035, 1502802140);
+            uint2 b2 = uint2(453681718, 66138830);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2 a3 = uint2(1691709825, 386789394);
+            uint2 b3 = uint2(1229799377, 1620922595);
+            bool2 r3 = bool2(false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_equal_wide_scalar()
+        {
+            uint2 a0 = uint2(1722165358, 1219858357);
+            uint b0 = (1688048545);
+            bool2 r0 = bool2(false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2 a1 = uint2(860410743, 348104022);
+            uint b1 = (411099660);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2 a2 = uint2(1963256951, 58924407);
+            uint b2 = (212084836);
+            bool2 r2 = bool2(false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2 a3 = uint2(1459242706, 532949158);
+            uint b3 = (1745758438);
+            bool2 r3 = bool2(true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint2 b0 = uint2(1181030049, 1787703989);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1729760948);
+            uint2 b1 = uint2(1816537388, 1359786460);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (874999193);
+            uint2 b2 = uint2(1678863148, 1711365839);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (762067160);
+            uint2 b3 = uint2(11953554, 1131583906);
+            bool2 r3 = bool2(false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_equal_wide_wide()
+        {
+            uint2 a0 = uint2(263000030, 744235661);
+            uint2 b0 = uint2(1395535146, 1178373944);
+            bool2 r0 = bool2(false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2 a1 = uint2(1893760267, 237248);
+            uint2 b1 = uint2(1237373760, 1364855321);
+            bool2 r1 = bool2(true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2 a2 = uint2(1062370984, 1676977687);
+            uint2 b2 = uint2(600811864, 362060472);
+            bool2 r2 = bool2(true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2 a3 = uint2(816766880, 1089431546);
+            uint2 b3 = uint2(290870624, 1839067862);
+            bool2 r3 = bool2(true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_equal_wide_scalar()
+        {
+            uint2 a0 = uint2(2112791350, 1043657935);
+            uint b0 = (1470533736);
+            bool2 r0 = bool2(true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2 a1 = uint2(101764761, 556026890);
+            uint b1 = (1529909067);
+            bool2 r1 = bool2(false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2 a2 = uint2(281734132, 815093894);
+            uint b2 = (1186600258);
+            bool2 r2 = bool2(false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2 a3 = uint2(609211196, 829548642);
+            uint b3 = (1604309397);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint2 b0 = uint2(1503244746, 861711266);
+            bool2 r0 = bool2(true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (817773856);
+            uint2 b1 = uint2(925984572, 571221723);
+            bool2 r1 = bool2(false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (683686810);
+            uint2 b2 = uint2(118252990, 1653952090);
+            bool2 r2 = bool2(true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (1240253990);
+            uint2 b3 = uint2(1947039008, 1869136019);
+            bool2 r3 = bool2(false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_add_wide_wide()
+        {
+            uint2 a0 = uint2(2049228671, 1658660009);
+            uint2 b0 = uint2(2088751567, 645762023);
+            uint2 r0 = uint2(4137980238, 2304422032);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2 a1 = uint2(491719392, 937013355);
+            uint2 b1 = uint2(306868786, 4360271);
+            uint2 r1 = uint2(798588178, 941373626);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2 a2 = uint2(81108663, 1063894558);
+            uint2 b2 = uint2(506047997, 2094559874);
+            uint2 r2 = uint2(587156660, 3158454432);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2 a3 = uint2(86954702, 843159721);
+            uint2 b3 = uint2(1634712736, 1601474440);
+            uint2 r3 = uint2(1721667438, 2444634161);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_add_wide_scalar()
+        {
+            uint2 a0 = uint2(2038218457, 134923711);
+            uint b0 = (2124409227);
+            uint2 r0 = uint2(4162627684, 2259332938);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2 a1 = uint2(875689667, 997710928);
+            uint b1 = (1338884463);
+            uint2 r1 = uint2(2214574130, 2336595391);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2 a2 = uint2(340490871, 70433301);
+            uint b2 = (1067888129);
+            uint2 r2 = uint2(1408379000, 1138321430);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2 a3 = uint2(2003021861, 1160398286);
+            uint b3 = (1635971971);
+            uint2 r3 = uint2(3638993832, 2796370257);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint2 b0 = uint2(519908870, 851424292);
+            uint2 r0 = uint2(911000948, 1242516370);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (328314822);
+            uint2 b1 = uint2(135622204, 740923360);
+            uint2 r1 = uint2(463937026, 1069238182);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (655394201);
+            uint2 b2 = uint2(1451896269, 1781697072);
+            uint2 r2 = uint2(2107290470, 2437091273);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (996031825);
+            uint2 b3 = uint2(1557774949, 779774940);
+            uint2 r3 = uint2(2553806774, 1775806765);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_sub_wide_wide()
+        {
+            uint2 a0 = uint2(1353441118, 797269833);
+            uint2 b0 = uint2(1332656812, 1827794007);
+            uint2 r0 = uint2(20784306, 3264443122);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2 a1 = uint2(659988112, 56022121);
+            uint2 b1 = uint2(972557431, 2078233689);
+            uint2 r1 = uint2(3982397977, 2272755728);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2 a2 = uint2(365847472, 2062899435);
+            uint2 b2 = uint2(1508184327, 1372307701);
+            uint2 r2 = uint2(3152630441, 690591734);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2 a3 = uint2(1380988474, 799885138);
+            uint2 b3 = uint2(810327977, 936799885);
+            uint2 r3 = uint2(570660497, 4158052549);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_sub_wide_scalar()
+        {
+            uint2 a0 = uint2(1176369558, 1934521195);
+            uint b0 = (462232403);
+            uint2 r0 = uint2(714137155, 1472288792);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2 a1 = uint2(309452150, 108910717);
+            uint b1 = (1417634074);
+            uint2 r1 = uint2(3186785372, 2986243939);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2 a2 = uint2(1306356714, 1451794815);
+            uint b2 = (1502312334);
+            uint2 r2 = uint2(4099011676, 4244449777);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2 a3 = uint2(281174200, 1913724431);
+            uint b3 = (87530840);
+            uint2 r3 = uint2(193643360, 1826193591);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint2 b0 = uint2(2022393810, 1612688515);
+            uint2 r0 = uint2(3964107891, 78845890);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (496689713);
+            uint2 b1 = uint2(887037586, 2097630964);
+            uint2 r1 = uint2(3904619423, 2694026045);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (374934538);
+            uint2 b2 = uint2(939035482, 935242277);
+            uint2 r2 = uint2(3730866352, 3734659557);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1789300421);
+            uint2 b3 = uint2(264712893, 1231856067);
+            uint2 r3 = uint2(1524587528, 557444354);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mul_wide_wide()
+        {
+            uint2 a0 = uint2(245827027, 208934650);
+            uint2 b0 = uint2(759663997, 350129201);
+            uint2 r0 = uint2(3662155527, 1402281434);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2 a1 = uint2(1019478917, 568231809);
+            uint2 b1 = uint2(477450108, 1635735015);
+            uint2 r1 = uint2(332447596, 2361989735);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2 a2 = uint2(877289039, 1585782440);
+            uint2 b2 = uint2(388710278, 757722665);
+            uint2 r2 = uint2(2624048730, 1455036648);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2 a3 = uint2(2111178729, 1186019069);
+            uint2 b3 = uint2(1509388321, 1841703980);
+            uint2 r3 = uint2(2128344329, 3700879228);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mul_wide_scalar()
+        {
+            uint2 a0 = uint2(1762033447, 465343930);
+            uint b0 = (1476837906);
+            uint2 r0 = uint2(2981789374, 1326807828);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2 a1 = uint2(1570757881, 1824319147);
+            uint b1 = (1326409563);
+            uint2 r1 = uint2(1666366339, 4042902473);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2 a2 = uint2(1356578909, 154616909);
+            uint b2 = (72749215);
+            uint2 r2 = uint2(130042307, 1400257491);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2 a3 = uint2(975743632, 1958912969);
+            uint b3 = (573770299);
+            uint2 r3 = uint2(414773040, 3595344211);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint2 b0 = uint2(1764461774, 657072478);
+            uint2 r0 = uint2(3344568648, 4192918280);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1459784358);
+            uint2 b1 = uint2(1610646683, 1632058826);
+            uint2 r1 = uint2(1040681602, 2635396348);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (868441654);
+            uint2 b2 = uint2(1408757883, 335917146);
+            uint2 r2 = uint2(1867178994, 2458009340);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (2105124483);
+            uint2 b3 = uint2(1178393968, 1963904348);
+            uint2 r3 = uint2(3266048080, 2084093460);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_div_wide_wide()
+        {
+            uint2 a0 = uint2(1590198532, 507812502);
+            uint2 b0 = uint2(1434703236, 911965201);
+            uint2 r0 = uint2(1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2 a1 = uint2(126627032, 1058247011);
+            uint2 b1 = uint2(390415521, 128746927);
+            uint2 r1 = uint2(0, 8);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2 a2 = uint2(427387861, 290676154);
+            uint2 b2 = uint2(525835375, 816946613);
+            uint2 r2 = uint2(0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2 a3 = uint2(1829594484, 1127868739);
+            uint2 b3 = uint2(878264647, 146789678);
+            uint2 r3 = uint2(2, 7);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_div_wide_scalar()
+        {
+            uint2 a0 = uint2(560951562, 1218680769);
+            uint b0 = (947861580);
+            uint2 r0 = uint2(0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2 a1 = uint2(375341724, 1919409166);
+            uint b1 = (1613542090);
+            uint2 r1 = uint2(0, 1);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2 a2 = uint2(1397425408, 524526253);
+            uint b2 = (1349573078);
+            uint2 r2 = uint2(1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2 a3 = uint2(341995568, 1515313790);
+            uint b3 = (495895326);
+            uint2 r3 = uint2(0, 3);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint2 b0 = uint2(187325733, 1594107378);
+            uint2 r0 = uint2(6, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (2016183849);
+            uint2 b1 = uint2(1589343709, 388768753);
+            uint2 r1 = uint2(1, 5);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1417077283);
+            uint2 b2 = uint2(1773486938, 1154044032);
+            uint2 r2 = uint2(0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (81831373);
+            uint2 b3 = uint2(1476877645, 653688843);
+            uint2 r3 = uint2(0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mod_wide_wide()
+        {
+            uint2 a0 = uint2(146150818, 1846543305);
+            uint2 b0 = uint2(983050390, 771341152);
+            uint2 r0 = uint2(146150818, 303861001);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2 a1 = uint2(1071447756, 308965362);
+            uint2 b1 = uint2(942375212, 367361754);
+            uint2 r1 = uint2(129072544, 308965362);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2 a2 = uint2(659881575, 1002365460);
+            uint2 b2 = uint2(749500619, 750718852);
+            uint2 r2 = uint2(659881575, 251646608);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2 a3 = uint2(861198439, 1510617532);
+            uint2 b3 = uint2(2095151755, 88438806);
+            uint2 r3 = uint2(861198439, 7157830);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mod_wide_scalar()
+        {
+            uint2 a0 = uint2(164800505, 1062177828);
+            uint b0 = (883951171);
+            uint2 r0 = uint2(164800505, 178226657);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2 a1 = uint2(1898749675, 820393245);
+            uint b1 = (1701653318);
+            uint2 r1 = uint2(197096357, 820393245);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2 a2 = uint2(19002208, 1464010899);
+            uint b2 = (128329633);
+            uint2 r2 = uint2(19002208, 52384936);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2 a3 = uint2(896587769, 1982762194);
+            uint b3 = (405208598);
+            uint2 r3 = uint2(86170573, 361927802);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint2 b0 = uint2(740000543, 1556450291);
+            uint2 r0 = uint2(242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1104736385);
+            uint2 b1 = uint2(437976569, 1911837205);
+            uint2 r1 = uint2(228783247, 1104736385);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (1507212038);
+            uint2 b2 = uint2(1906405167, 247693265);
+            uint2 r2 = uint2(1507212038, 21052448);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (293460573);
+            uint2 b3 = uint2(1495295166, 873323603);
+            uint2 r3 = uint2(293460573, 293460573);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_plus()
+        {
+            uint2 a0 = uint2(1643476803, 907898539);
+            uint2 r0 = uint2(1643476803, 907898539);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint2 a1 = uint2(379615839, 1735287433);
+            uint2 r1 = uint2(379615839, 1735287433);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint2 a2 = uint2(1743199272, 339091479);
+            uint2 r2 = uint2(1743199272, 339091479);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint2 a3 = uint2(401565897, 849339193);
+            uint2 r3 = uint2(401565897, 849339193);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_neg()
+        {
+            uint2 a0 = uint2(1955022112, 662160019);
+            uint2 r0 = uint2(2339945184, 3632807277);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint2 a1 = uint2(370300775, 1004505619);
+            uint2 r1 = uint2(3924666521, 3290461677);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint2 a2 = uint2(28153593, 505708349);
+            uint2 r2 = uint2(4266813703, 3789258947);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint2 a3 = uint2(1115028238, 694995093);
+            uint2 r3 = uint2(3179939058, 3599972203);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_prefix_inc()
+        {
+            uint2 a0 = uint2(864455342, 2035793213);
+            uint2 r0 = uint2(864455343, 2035793214);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint2 a1 = uint2(1275443862, 411610189);
+            uint2 r1 = uint2(1275443863, 411610190);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint2 a2 = uint2(446210725, 115573442);
+            uint2 r2 = uint2(446210726, 115573443);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint2 a3 = uint2(913293639, 1208161871);
+            uint2 r3 = uint2(913293640, 1208161872);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_postfix_inc()
+        {
+            uint2 a0 = uint2(1751003569, 2063707595);
+            uint2 r0 = uint2(1751003569, 2063707595);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint2 a1 = uint2(1500486291, 1007848192);
+            uint2 r1 = uint2(1500486291, 1007848192);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint2 a2 = uint2(2028651936, 1190630527);
+            uint2 r2 = uint2(2028651936, 1190630527);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint2 a3 = uint2(1396179607, 177416855);
+            uint2 r3 = uint2(1396179607, 177416855);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_prefix_dec()
+        {
+            uint2 a0 = uint2(200904609, 871077500);
+            uint2 r0 = uint2(200904608, 871077499);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint2 a1 = uint2(968578728, 1995396216);
+            uint2 r1 = uint2(968578727, 1995396215);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint2 a2 = uint2(435367037, 1589827826);
+            uint2 r2 = uint2(435367036, 1589827825);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint2 a3 = uint2(1434377580, 1699290403);
+            uint2 r3 = uint2(1434377579, 1699290402);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_postfix_dec()
+        {
+            uint2 a0 = uint2(283970262, 1109329936);
+            uint2 r0 = uint2(283970262, 1109329936);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint2 a1 = uint2(1073216143, 1932646215);
+            uint2 r1 = uint2(1073216143, 1932646215);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint2 a2 = uint2(1174104498, 524156737);
+            uint2 r2 = uint2(1174104498, 524156737);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint2 a3 = uint2(691209285, 802721301);
+            uint2 r3 = uint2(691209285, 802721301);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_and_wide_wide()
+        {
+            uint2 a0 = uint2(779935043, 1097962163);
+            uint2 b0 = uint2(307705143, 1710882162);
+            uint2 r0 = uint2(39064835, 1097961522);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2 a1 = uint2(1939593304, 800599247);
+            uint2 b1 = uint2(866836769, 532490608);
+            uint2 r1 = uint2(864731136, 263727168);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2 a2 = uint2(952140918, 782792558);
+            uint2 b2 = uint2(679371720, 1794035877);
+            uint2 r2 = uint2(675283008, 715673636);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2 a3 = uint2(1608557706, 396446406);
+            uint2 b3 = uint2(1439832202, 519529812);
+            uint2 r3 = uint2(1438646410, 379666500);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_and_wide_scalar()
+        {
+            uint2 a0 = uint2(443615469, 490057985);
+            uint b0 = (93423598);
+            uint2 r0 = uint2(1114348, 85033216);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2 a1 = uint2(2042441263, 1405175110);
+            uint b1 = (1524760558);
+            uint2 r1 = uint2(1486958126, 1388397894);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2 a2 = uint2(510212004, 1236735839);
+            uint b2 = (1941875181);
+            uint2 r2 = uint2(304619940, 1102446925);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2 a3 = uint2(1365509729, 607982857);
+            uint b3 = (428270198);
+            uint2 r3 = uint2(285475424, 262144);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint2 b0 = uint2(420346723, 562416448);
+            uint2 r0 = uint2(547170, 18752);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1393127318);
+            uint2 b1 = uint2(1560699552, 851218057);
+            uint2 r1 = uint2(1358979712, 302517888);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (703880958);
+            uint2 b2 = uint2(1159378889, 2031211279);
+            uint2 r2 = uint2(17831624, 688935438);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1089518981);
+            uint2 b3 = uint2(270607307, 1349288930);
+            uint2 r3 = uint2(2105729, 1080066432);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_or_wide_wide()
+        {
+            uint2 a0 = uint2(1731159103, 659068416);
+            uint2 b0 = uint2(1583847161, 692672727);
+            uint2 r0 = uint2(2138044159, 793370327);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2 a1 = uint2(382702471, 1821032196);
+            uint2 b1 = uint2(1161585489, 1756207130);
+            uint2 r1 = uint2(1476391895, 1823457054);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2 a2 = uint2(1565773438, 1004000514);
+            uint2 b2 = uint2(1321374429, 1287357212);
+            uint2 r2 = uint2(1607720703, 2147473182);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2 a3 = uint2(948501377, 600951835);
+            uint2 b3 = uint2(2075767170, 1273513430);
+            uint2 r3 = uint2(2075786115, 1811533279);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_or_wide_scalar()
+        {
+            uint2 a0 = uint2(961259683, 471103264);
+            uint b0 = (1666102508);
+            uint2 r0 = uint2(2068823279, 2136930284);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2 a1 = uint2(1733389229, 386953869);
+            uint b1 = (1591585258);
+            uint2 r1 = uint2(2145250287, 1608383471);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2 a2 = uint2(1148351449, 1814263250);
+            uint b2 = (1048929715);
+            uint2 r2 = uint2(2130147323, 2124903923);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2 a3 = uint2(860336789, 1227888278);
+            uint b3 = (1637162093);
+            uint2 r3 = uint2(1943518973, 1773477631);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint2 b0 = uint2(1212928242, 1614462616);
+            uint2 r0 = uint2(1213978111, 1752940445);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (936937728);
+            uint2 b1 = uint2(764766995, 306352095);
+            uint2 r1 = uint2(1071508243, 937070559);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (574719481);
+            uint2 b2 = uint2(1283571271, 2109131012);
+            uint2 r2 = uint2(1858191359, 2146946557);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (979469710);
+            uint2 b3 = uint2(1348323481, 1407542578);
+            uint2 r3 = uint2(2055064991, 2078664126);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_xor_wide_wide()
+        {
+            uint2 a0 = uint2(1556324760, 207002929);
+            uint2 b0 = uint2(1054997548, 1523759632);
+            uint2 r0 = uint2(1646419380, 1451501345);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2 a1 = uint2(1843444873, 1632079131);
+            uint2 b1 = uint2(251164872, 110472397);
+            uint2 r1 = uint2(1662567489, 1741824470);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2 a2 = uint2(1460334334, 1607815585);
+            uint2 b2 = uint2(384031112, 1109163205);
+            uint2 r2 = uint2(1105803126, 499723620);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2 a3 = uint2(220623650, 38668553);
+            uint2 b3 = uint2(535118981, 179106262);
+            uint2 r3 = uint2(314783655, 149092575);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_xor_wide_scalar()
+        {
+            uint2 a0 = uint2(2124666952, 177397845);
+            uint b0 = (493665894);
+            uint2 r0 = uint2(1674536494, 402546227);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2 a1 = uint2(574879617, 1136545648);
+            uint b1 = (1937385541);
+            uint2 r1 = uint2(1362747332, 818177845);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2 a2 = uint2(213863690, 289301586);
+            uint b2 = (535061373);
+            uint2 r2 = uint2(324742775, 249169711);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2 a3 = uint2(1305234431, 1308626970);
+            uint b3 = (353786540);
+            uint2 r3 = uint2(1490686291, 1528187574);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint2 b0 = uint2(1077599928, 884741329);
+            uint2 r0 = uint2(217506340, 2020616269);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (212164516);
+            uint2 b1 = uint2(1585020328, 152985454);
+            uint2 r1 = uint2(1390158348, 96141514);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1775851275);
+            uint2 b2 = uint2(1416249064, 1309317737);
+            uint2 r2 = uint2(1035168227, 668192098);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1773918217);
+            uint2 b3 = uint2(1509843030, 1206045972);
+            uint2 r3 = uint2(809875551, 777590045);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_left_shift()
+        {
+            uint2 a0 = uint2(197771193, 622182602);
+            int b0 = (1321149625);
+            uint2 r0 = uint2(1912602624, 2483027968);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint2 a1 = uint2(1283988958, 473415985);
+            int b1 = (1327917304);
+            uint2 r1 = uint2(3724541952, 822083584);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint2 a2 = uint2(432425717, 2058433484);
+            int b2 = (870301196);
+            uint2 r2 = uint2(1689210880, 322748416);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint2 a3 = uint2(1200694230, 1360008038);
+            int b3 = (1531607705);
+            uint2 r3 = uint2(2885681152, 3422552064);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_right_shift()
+        {
+            uint2 a0 = uint2(548167301, 1161338299);
+            int b0 = (1266801540);
+            uint2 r0 = uint2(34260456, 72583643);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint2 a1 = uint2(1617625829, 713958715);
+            int b1 = (1860731847);
+            uint2 r1 = uint2(12637701, 5577802);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint2 a2 = uint2(196552656, 1265099998);
+            int b2 = (770466193);
+            uint2 r2 = uint2(1499, 9651);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint2 a3 = uint2(572763124, 426807581);
+            int b3 = (506619530);
+            uint2 r3 = uint2(559338, 416804);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_operator_bitwise_not()
+        {
+            uint2 a0 = uint2(1403358969, 831360921);
+            uint2 r0 = uint2(2891608326, 3463606374);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint2 a1 = uint2(2088190243, 878283189);
+            uint2 r1 = uint2(2206777052, 3416684106);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint2 a2 = uint2(308994339, 1420884856);
+            uint2 r2 = uint2(3985972956, 2874082439);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint2 a3 = uint2(472965491, 627580960);
+            uint2 r3 = uint2(3822001804, 3667386335);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2_shuffle_result_1()
+        {
+            uint2 a = uint2(0, 1);
+            uint2 b = uint2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (3));
+        }
+
+        [TestCompiler]
+        public static void uint2_shuffle_result_2()
+        {
+            uint2 a = uint2(0, 1);
+            uint2 b = uint2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX), uint2(0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftX), uint2(1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), uint2(2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX), uint2(3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY), uint2(0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint2(1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY), uint2(2, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), uint2(3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightX), uint2(0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint2(1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX), uint2(2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), uint2(3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint2(0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint2(1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY), uint2(2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), uint2(3, 3));
+        }
+
+        [TestCompiler]
+        public static void uint2_shuffle_result_3()
+        {
+            uint2 a = uint2(0, 1);
+            uint2 b = uint2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY), uint3(2, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightX), uint3(2, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint3(3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint3(1, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint3(2, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), uint3(0, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint3(2, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftX), uint3(3, 3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), uint3(2, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX), uint3(2, 2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint3(0, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY), uint3(3, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint3(0, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightX), uint3(3, 2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint3(0, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint3(3, 1, 1));
+        }
+
+        [TestCompiler]
+        public static void uint2_shuffle_result_4()
+        {
+            uint2 a = uint2(0, 1);
+            uint2 b = uint2(2, 3);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint4(0, 0, 1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(2, 1, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX), uint4(3, 2, 3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), uint4(2, 0, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightX), uint4(0, 3, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftY), uint4(3, 0, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftX), uint4(2, 2, 3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(2, 2, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX, ShuffleComponent.LeftY), uint4(0, 1, 2, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightY), uint4(2, 1, 3, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftY), uint4(3, 3, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint4(2, 2, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), uint4(3, 0, 0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), uint4(2, 2, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(0, 3, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), uint4(2, 0, 0, 0));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..ade3bfc6cfba6a786999a0761c6f220d1def8f14
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b6fc6b61ea1f4f42944befb17029ea1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..43881d003aba73e0e72c0e37ee14b9c681601100
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs
@@ -0,0 +1,1234 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint2x2
+    {
+        [TestCompiler]
+        public static void uint2x2_zero()
+        {
+            TestUtils.AreEqual(uint2x2.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint2x2.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint2x2.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint2x2.zero.c1.y, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_identity()
+        {
+            TestUtils.AreEqual(uint2x2.identity.c0.x, 1u);
+            TestUtils.AreEqual(uint2x2.identity.c0.y, 0u);
+            TestUtils.AreEqual(uint2x2.identity.c1.x, 0u);
+            TestUtils.AreEqual(uint2x2.identity.c1.y, 1u);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_equal_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(790229414, 970783976, 1428432738, 1578747135);
+            uint2x2 b0 = uint2x2(612337669, 1214209108, 2120643427, 295461214);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x2 a1 = uint2x2(1733797753, 2001507228, 1446876437, 1777406370);
+            uint2x2 b1 = uint2x2(1510890331, 1893316566, 921816149, 1834958575);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x2 a2 = uint2x2(1426387268, 1809275021, 1843770816, 1172185222);
+            uint2x2 b2 = uint2x2(1482011863, 2062852792, 226398742, 770290735);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x2 a3 = uint2x2(1469608940, 869874758, 458603090, 581282460);
+            uint2x2 b3 = uint2x2(36812057, 543224481, 1565350150, 1909926604);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_equal_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(1211464300, 1921862607, 508076684, 1249127920);
+            uint b0 = (746972502);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x2 a1 = uint2x2(1394594555, 1733655277, 1884008277, 1682018538);
+            uint b1 = (746862310);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x2 a2 = uint2x2(795585660, 927605411, 672785749, 1465584610);
+            uint b2 = (936027116);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x2 a3 = uint2x2(585324157, 969511077, 442746747, 1772925698);
+            uint b3 = (404448210);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint2x2 b0 = uint2x2(233855098, 924242519, 1402948791, 601381975);
+            bool2x2 r0 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (2120518068);
+            uint2x2 b1 = uint2x2(629187703, 1971977031, 47183124, 1061805787);
+            bool2x2 r1 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (1009011238);
+            uint2x2 b2 = uint2x2(312511148, 1460673064, 737210539, 1737844479);
+            bool2x2 r2 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1892405453);
+            uint2x2 b3 = uint2x2(2133024000, 455818693, 2003197687, 1276241219);
+            bool2x2 r3 = bool2x2(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_not_equal_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1660932106, 982847023, 97046264, 1739517447);
+            uint2x2 b0 = uint2x2(107139049, 75478496, 2055495054, 358586687);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x2 a1 = uint2x2(1253499180, 1830584069, 1841470429, 1397841646);
+            uint2x2 b1 = uint2x2(942338347, 111564990, 113811950, 948912488);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x2 a2 = uint2x2(1770890135, 1906548631, 169082967, 2099271786);
+            uint2x2 b2 = uint2x2(1080084121, 1400504872, 1032134499, 1061123400);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x2 a3 = uint2x2(1909317609, 46519139, 1433204003, 931492669);
+            uint2x2 b3 = uint2x2(221862069, 858950046, 989094643, 2023070999);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_not_equal_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(747758183, 1033001286, 1439973882, 2138928797);
+            uint b0 = (248693828);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x2 a1 = uint2x2(1197845089, 950170763, 238704450, 2105962247);
+            uint b1 = (1432672459);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x2 a2 = uint2x2(727205263, 276313906, 2126300423, 791998981);
+            uint b2 = (1640688041);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x2 a3 = uint2x2(2035077187, 1412347883, 1622176923, 768370497);
+            uint b3 = (1171827730);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint2x2 b0 = uint2x2(2037494727, 1989050616, 48833929, 1897435904);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (514354517);
+            uint2x2 b1 = uint2x2(1783749164, 364694471, 754315072, 124108032);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (1512967900);
+            uint2x2 b2 = uint2x2(1178825850, 1854793298, 50286949, 2100802631);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1640811853);
+            uint2x2 b3 = uint2x2(82110247, 472172806, 266984506, 2003668365);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1182186063, 415538999, 1667335818, 1566618442);
+            uint2x2 b0 = uint2x2(524633529, 1032195686, 760723389, 1505751409);
+            bool2x2 r0 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x2 a1 = uint2x2(1166180837, 639095188, 1080836365, 771119973);
+            uint2x2 b1 = uint2x2(431962172, 1287906509, 1560084663, 1450178202);
+            bool2x2 r1 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x2 a2 = uint2x2(928263233, 789225474, 665243110, 1003542034);
+            uint2x2 b2 = uint2x2(2066166337, 1107069023, 1640077524, 2103263105);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x2 a3 = uint2x2(1032480172, 1961336172, 923379558, 21210619);
+            uint2x2 b3 = uint2x2(684229139, 1234033624, 1278743281, 1953079347);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(608447185, 818840405, 869219329, 2080125385);
+            uint b0 = (1491216667);
+            bool2x2 r0 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x2 a1 = uint2x2(1214500548, 1667165786, 1615392341, 840091491);
+            uint b1 = (1361741203);
+            bool2x2 r1 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x2 a2 = uint2x2(469591900, 315321650, 930950514, 1100560246);
+            uint b2 = (1247103789);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x2 a3 = uint2x2(933855388, 1127696709, 1286331950, 380753337);
+            uint b3 = (908563901);
+            bool2x2 r3 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint2x2 b0 = uint2x2(282703327, 14370648, 1862117300, 1304793311);
+            bool2x2 r0 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (826073259);
+            uint2x2 b1 = uint2x2(988910157, 445132446, 1139670255, 111349251);
+            bool2x2 r1 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1102440676);
+            uint2x2 b2 = uint2x2(112183144, 1594415311, 1890019295, 2098715503);
+            bool2x2 r2 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (608933527);
+            uint2x2 b3 = uint2x2(183989010, 1596056507, 1027318999, 146281093);
+            bool2x2 r3 = bool2x2(false, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(592884447, 2133928932, 918957182, 1284069471);
+            uint2x2 b0 = uint2x2(138737040, 192863971, 1700841444, 1044631301);
+            bool2x2 r0 = bool2x2(true, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x2 a1 = uint2x2(194584707, 739120780, 241654068, 1340158550);
+            uint2x2 b1 = uint2x2(1391589821, 730837695, 253553987, 2078872742);
+            bool2x2 r1 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x2 a2 = uint2x2(2099542537, 1182623667, 1399607274, 789301637);
+            uint2x2 b2 = uint2x2(910845808, 976047676, 202633078, 1223618940);
+            bool2x2 r2 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x2 a3 = uint2x2(180400925, 594688333, 1877031463, 1360073500);
+            uint2x2 b3 = uint2x2(641600530, 1830470354, 1570701388, 1104256103);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(1097138316, 211763648, 1883002501, 56406996);
+            uint b0 = (438688675);
+            bool2x2 r0 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x2 a1 = uint2x2(43662641, 1437755186, 1219010035, 2125058448);
+            uint b1 = (1923456111);
+            bool2x2 r1 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x2 a2 = uint2x2(304028799, 48044515, 711945018, 1035679270);
+            uint b2 = (893125636);
+            bool2x2 r2 = bool2x2(false, false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x2 a3 = uint2x2(577943770, 1016617211, 2063134811, 1577403353);
+            uint b3 = (572743717);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint2x2 b0 = uint2x2(599356784, 185671342, 1932327391, 2025591013);
+            bool2x2 r0 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1257191721);
+            uint2x2 b1 = uint2x2(1312388500, 1443698859, 779217735, 691047512);
+            bool2x2 r1 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (741776730);
+            uint2x2 b2 = uint2x2(732565983, 668302204, 1556466996, 858599525);
+            bool2x2 r2 = bool2x2(true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (1896917159);
+            uint2x2 b3 = uint2x2(701542098, 1052151621, 1023307544, 1435392907);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_equal_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1577248162, 2043073061, 1688380407, 176431985);
+            uint2x2 b0 = uint2x2(903445031, 2108974565, 210822256, 1281704747);
+            bool2x2 r0 = bool2x2(false, true, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x2 a1 = uint2x2(223299035, 1502802140, 1691709825, 386789394);
+            uint2x2 b1 = uint2x2(453681718, 66138830, 1229799377, 1620922595);
+            bool2x2 r1 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x2 a2 = uint2x2(117182003, 1665770435, 1958490731, 420032601);
+            uint2x2 b2 = uint2x2(1715833766, 1366430432, 13102000, 46919981);
+            bool2x2 r2 = bool2x2(true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x2 a3 = uint2x2(1251092689, 2011681765, 749743684, 183784440);
+            uint2x2 b3 = uint2x2(486470891, 1709514236, 2145785285, 854254454);
+            bool2x2 r3 = bool2x2(false, false, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_equal_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(1722165358, 1219858357, 860410743, 411099660);
+            uint b0 = (1688048545);
+            bool2x2 r0 = bool2x2(false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x2 a1 = uint2x2(348104022, 212084836, 58924407, 1459242706);
+            uint b1 = (1963256951);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x2 a2 = uint2x2(1745758438, 262559763, 690091301, 1806172431);
+            uint b2 = (532949158);
+            bool2x2 r2 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x2 a3 = uint2x2(2091514001, 1617221948, 2017733017, 804204255);
+            uint b3 = (1857173043);
+            bool2x2 r3 = bool2x2(false, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint2x2 b0 = uint2x2(1181030049, 1787703989, 1729760948, 1816537388);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1359786460);
+            uint2x2 b1 = uint2x2(874999193, 1678863148, 1711365839, 762067160);
+            bool2x2 r1 = bool2x2(false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (11953554);
+            uint2x2 b2 = uint2x2(1131583906, 1175393186, 1293698493, 48893340);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (66196247);
+            uint2x2 b3 = uint2x2(1958607116, 1576473309, 861890786, 478252419);
+            bool2x2 r3 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_equal_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(263000030, 744235661, 1893760267, 237248);
+            uint2x2 b0 = uint2x2(1395535146, 1178373944, 1237373760, 1364855321);
+            bool2x2 r0 = bool2x2(false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x2 a1 = uint2x2(1062370984, 1676977687, 816766880, 1089431546);
+            uint2x2 b1 = uint2x2(600811864, 362060472, 290870624, 1839067862);
+            bool2x2 r1 = bool2x2(true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x2 a2 = uint2x2(1394493730, 1176473380, 1193988637, 1703862455);
+            uint2x2 b2 = uint2x2(396958580, 1336888643, 1019684398, 1697684196);
+            bool2x2 r2 = bool2x2(true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x2 a3 = uint2x2(1806186947, 1253571980, 589397635, 1951842887);
+            uint2x2 b3 = uint2x2(1227300220, 2044269675, 1898323839, 874509380);
+            bool2x2 r3 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_equal_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(2112791350, 1043657935, 101764761, 1529909067);
+            uint b0 = (1470533736);
+            bool2x2 r0 = bool2x2(true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x2 a1 = uint2x2(556026890, 1186600258, 815093894, 609211196);
+            uint b1 = (281734132);
+            bool2x2 r1 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x2 a2 = uint2x2(1604309397, 244604867, 1419295004, 471843809);
+            uint b2 = (829548642);
+            bool2x2 r2 = bool2x2(true, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x2 a3 = uint2x2(1819986195, 1646290021, 196833647, 1596738181);
+            uint b3 = (1460027917);
+            bool2x2 r3 = bool2x2(true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint2x2 b0 = uint2x2(1503244746, 861711266, 817773856, 925984572);
+            bool2x2 r0 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (571221723);
+            uint2x2 b1 = uint2x2(683686810, 118252990, 1653952090, 1240253990);
+            bool2x2 r1 = bool2x2(false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (1947039008);
+            uint2x2 b2 = uint2x2(1869136019, 152012637, 1214546726, 917376832);
+            bool2x2 r2 = bool2x2(true, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (303549425);
+            uint2x2 b3 = uint2x2(2111728811, 945321577, 173706579, 625318949);
+            bool2x2 r3 = bool2x2(false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_add_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(2049228671, 1658660009, 491719392, 937013355);
+            uint2x2 b0 = uint2x2(2088751567, 645762023, 306868786, 4360271);
+            uint2x2 r0 = uint2x2(4137980238, 2304422032, 798588178, 941373626);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x2 a1 = uint2x2(81108663, 1063894558, 86954702, 843159721);
+            uint2x2 b1 = uint2x2(506047997, 2094559874, 1634712736, 1601474440);
+            uint2x2 r1 = uint2x2(587156660, 3158454432, 1721667438, 2444634161);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x2 a2 = uint2x2(698977704, 192867135, 1683407172, 137301303);
+            uint2x2 b2 = uint2x2(1586485231, 908746788, 1812370320, 1247342357);
+            uint2x2 r2 = uint2x2(2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x2 a3 = uint2x2(2103582820, 526139155, 447937230, 2127411006);
+            uint2x2 b3 = uint2x2(2043773873, 223363428, 175115707, 985928617);
+            uint2x2 r3 = uint2x2(4147356693, 749502583, 623052937, 3113339623);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_add_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(2038218457, 134923711, 875689667, 1338884463);
+            uint b0 = (2124409227);
+            uint2x2 r0 = uint2x2(4162627684, 2259332938, 3000098894, 3463293690);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x2 a1 = uint2x2(997710928, 1067888129, 70433301, 2003021861);
+            uint b1 = (340490871);
+            uint2x2 r1 = uint2x2(1338201799, 1408379000, 410924172, 2343512732);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x2 a2 = uint2x2(1635971971, 85446202, 1068152966, 1239387100);
+            uint b2 = (1160398286);
+            uint2x2 r2 = uint2x2(2796370257, 1245844488, 2228551252, 2399785386);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x2 a3 = uint2x2(1497676888, 1095438654, 756559204, 1818718931);
+            uint b3 = (1727477485);
+            uint2x2 r3 = uint2x2(3225154373, 2822916139, 2484036689, 3546196416);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint2x2 b0 = uint2x2(519908870, 851424292, 328314822, 135622204);
+            uint2x2 r0 = uint2x2(911000948, 1242516370, 719406900, 526714282);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (740923360);
+            uint2x2 b1 = uint2x2(655394201, 1451896269, 1781697072, 996031825);
+            uint2x2 r1 = uint2x2(1396317561, 2192819629, 2522620432, 1736955185);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1557774949);
+            uint2x2 b2 = uint2x2(779774940, 1111541302, 783046445, 1130163944);
+            uint2x2 r2 = uint2x2(2337549889, 2669316251, 2340821394, 2687938893);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (288279584);
+            uint2x2 b3 = uint2x2(1397683861, 1636583489, 673263339, 1469300874);
+            uint2x2 r3 = uint2x2(1685963445, 1924863073, 961542923, 1757580458);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_sub_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1353441118, 797269833, 659988112, 56022121);
+            uint2x2 b0 = uint2x2(1332656812, 1827794007, 972557431, 2078233689);
+            uint2x2 r0 = uint2x2(20784306, 3264443122, 3982397977, 2272755728);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x2 a1 = uint2x2(365847472, 2062899435, 1380988474, 799885138);
+            uint2x2 b1 = uint2x2(1508184327, 1372307701, 810327977, 936799885);
+            uint2x2 r1 = uint2x2(3152630441, 690591734, 570660497, 4158052549);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x2 a2 = uint2x2(1306058185, 579775276, 1239163824, 344591081);
+            uint2x2 b2 = uint2x2(71562303, 1418723328, 1971342989, 1226053395);
+            uint2x2 r2 = uint2x2(1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x2 a3 = uint2x2(86359575, 1049709943, 721529513, 1767221271);
+            uint2x2 b3 = uint2x2(136565478, 1979903295, 600719425, 837912956);
+            uint2x2 r3 = uint2x2(4244761393, 3364773944, 120810088, 929308315);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_sub_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(1176369558, 1934521195, 309452150, 1417634074);
+            uint b0 = (462232403);
+            uint2x2 r0 = uint2x2(714137155, 1472288792, 4142187043, 955401671);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x2 a1 = uint2x2(108910717, 1502312334, 1451794815, 281174200);
+            uint b1 = (1306356714);
+            uint2x2 r1 = uint2x2(3097521299, 195955620, 145438101, 3269784782);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x2 a2 = uint2x2(87530840, 2041593336, 557239990, 1119051448);
+            uint b2 = (1913724431);
+            uint2x2 r2 = uint2x2(2468773705, 127868905, 2938482855, 3500294313);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x2 a3 = uint2x2(1590376732, 816382635, 815920639, 1829033117);
+            uint b3 = (819090189);
+            uint2x2 r3 = uint2x2(771286543, 4292259742, 4291797746, 1009942928);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint2x2 b0 = uint2x2(2022393810, 1612688515, 496689713, 887037586);
+            uint2x2 r0 = uint2x2(3964107891, 78845890, 1194844692, 804496819);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (2097630964);
+            uint2x2 b1 = uint2x2(374934538, 939035482, 935242277, 1789300421);
+            uint2x2 r1 = uint2x2(1722696426, 1158595482, 1162388687, 308330543);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (264712893);
+            uint2x2 b2 = uint2x2(1231856067, 1818112748, 1428436109, 1258745460);
+            uint2x2 r2 = uint2x2(3327824122, 2741567441, 3131244080, 3300934729);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1077380396);
+            uint2x2 b3 = uint2x2(1330722719, 518111829, 967128529, 344666254);
+            uint2x2 r3 = uint2x2(4041624973, 559268567, 110251867, 732714142);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mul_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(245827027, 208934650, 1019478917, 568231809);
+            uint2x2 b0 = uint2x2(759663997, 350129201, 477450108, 1635735015);
+            uint2x2 r0 = uint2x2(3662155527, 1402281434, 332447596, 2361989735);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x2 a1 = uint2x2(877289039, 1585782440, 2111178729, 1186019069);
+            uint2x2 b1 = uint2x2(388710278, 757722665, 1509388321, 1841703980);
+            uint2x2 r1 = uint2x2(2624048730, 1455036648, 2128344329, 3700879228);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x2 a2 = uint2x2(571481445, 1570087048, 629447153, 619383734);
+            uint2x2 b2 = uint2x2(1826369331, 1524322467, 1605207974, 428419155);
+            uint2x2 r2 = uint2x2(2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x2 a3 = uint2x2(2055121568, 700402816, 263414349, 187830569);
+            uint2x2 b3 = uint2x2(1460605791, 1968043860, 771161742, 2037340417);
+            uint2x2 r3 = uint2x2(990589280, 3356793344, 2953243830, 1156600361);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mul_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(1762033447, 465343930, 1570757881, 1326409563);
+            uint b0 = (1476837906);
+            uint2x2 r0 = uint2x2(2981789374, 1326807828, 2156411778, 4018813542);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x2 a1 = uint2x2(1824319147, 72749215, 154616909, 975743632);
+            uint b1 = (1356578909);
+            uint2x2 r1 = uint2x2(4058582047, 130042307, 1244434425, 2313287248);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x2 a2 = uint2x2(573770299, 971327747, 1818877398, 1324050764);
+            uint b2 = (1958912969);
+            uint2x2 r2 = uint2x2(3595344211, 583613531, 2609540870, 377032876);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x2 a3 = uint2x2(660611671, 391009467, 1186856590, 890343818);
+            uint b3 = (1279757657);
+            uint2x2 r3 = uint2x2(4252425023, 1120105475, 4272141662, 1972017914);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint2x2 b0 = uint2x2(1764461774, 657072478, 1459784358, 1610646683);
+            uint2x2 r0 = uint2x2(3344568648, 4192918280, 1260585960, 1158730452);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1632058826);
+            uint2x2 b1 = uint2x2(868441654, 1408757883, 335917146, 2105124483);
+            uint2x2 r1 = uint2x2(4237636764, 2735607822, 712546564, 3489634910);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1178393968);
+            uint2x2 b2 = uint2x2(1963904348, 1409533767, 243286231, 1336308795);
+            uint2x2 r2 = uint2x2(1196573760, 592673296, 209320208, 3942500560);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (517963367);
+            uint2x2 b3 = uint2x2(1733623488, 459880225, 994616533, 1420531535);
+            uint2x2 r3 = uint2x2(3520397120, 3023465543, 652617651, 2505294537);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_div_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1590198532, 507812502, 126627032, 1058247011);
+            uint2x2 b0 = uint2x2(1434703236, 911965201, 390415521, 128746927);
+            uint2x2 r0 = uint2x2(1, 0, 0, 8);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x2 a1 = uint2x2(427387861, 290676154, 1829594484, 1127868739);
+            uint2x2 b1 = uint2x2(525835375, 816946613, 878264647, 146789678);
+            uint2x2 r1 = uint2x2(0, 0, 2, 7);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x2 a2 = uint2x2(499016351, 1341209632, 134906097, 785470242);
+            uint2x2 b2 = uint2x2(2089524057, 254213018, 1916850021, 1737806518);
+            uint2x2 r2 = uint2x2(0, 5, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x2 a3 = uint2x2(788249865, 1099825433, 1552968283, 1822367139);
+            uint2x2 b3 = uint2x2(1906634983, 437754923, 825037958, 902508708);
+            uint2x2 r3 = uint2x2(0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_div_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(560951562, 1218680769, 375341724, 1613542090);
+            uint b0 = (947861580);
+            uint2x2 r0 = uint2x2(0, 1, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x2 a1 = uint2x2(1919409166, 1349573078, 524526253, 341995568);
+            uint b1 = (1397425408);
+            uint2x2 r1 = uint2x2(1, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x2 a2 = uint2x2(495895326, 1676971657, 2131487088, 2105094094);
+            uint b2 = (1515313790);
+            uint2x2 r2 = uint2x2(0, 1, 1, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x2 a3 = uint2x2(1017891310, 1646044372, 1447236569, 107215658);
+            uint b3 = (542666029);
+            uint2x2 r3 = uint2x2(1, 3, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint2x2 b0 = uint2x2(187325733, 1594107378, 2016183849, 1589343709);
+            uint2x2 r0 = uint2x2(6, 0, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (388768753);
+            uint2x2 b1 = uint2x2(1417077283, 1773486938, 1154044032, 81831373);
+            uint2x2 r1 = uint2x2(0, 0, 0, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1476877645);
+            uint2x2 b2 = uint2x2(653688843, 45756703, 631027637, 396671391);
+            uint2x2 r2 = uint2x2(2, 32, 2, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (784365696);
+            uint2x2 b3 = uint2x2(1250594097, 1818363859, 1653451772, 270557729);
+            uint2x2 r3 = uint2x2(0, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mod_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(146150818, 1846543305, 1071447756, 308965362);
+            uint2x2 b0 = uint2x2(983050390, 771341152, 942375212, 367361754);
+            uint2x2 r0 = uint2x2(146150818, 303861001, 129072544, 308965362);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x2 a1 = uint2x2(659881575, 1002365460, 861198439, 1510617532);
+            uint2x2 b1 = uint2x2(749500619, 750718852, 2095151755, 88438806);
+            uint2x2 r1 = uint2x2(659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x2 a2 = uint2x2(778525078, 1458458044, 101987897, 1249565173);
+            uint2x2 b2 = uint2x2(769227442, 647214624, 1026513788, 1544950956);
+            uint2x2 r2 = uint2x2(9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x2 a3 = uint2x2(938026607, 1692541775, 1518877124, 1806965510);
+            uint2x2 b3 = uint2x2(160166322, 1099108075, 1158422232, 1798905209);
+            uint2x2 r3 = uint2x2(137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mod_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(164800505, 1062177828, 1898749675, 1701653318);
+            uint b0 = (883951171);
+            uint2x2 r0 = uint2x2(164800505, 178226657, 130847333, 817702147);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x2 a1 = uint2x2(820393245, 128329633, 1464010899, 896587769);
+            uint b1 = (19002208);
+            uint2x2 r1 = uint2x2(3298301, 14316385, 840883, 3483993);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x2 a2 = uint2x2(405208598, 959236935, 712321026, 172564850);
+            uint b2 = (1982762194);
+            uint2x2 r2 = uint2x2(405208598, 959236935, 712321026, 172564850);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x2 a3 = uint2x2(1540068445, 1607489717, 165478511, 647846716);
+            uint b3 = (1085897743);
+            uint2x2 r3 = uint2x2(454170702, 521591974, 165478511, 647846716);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint2x2 b0 = uint2x2(740000543, 1556450291, 1104736385, 437976569);
+            uint2x2 r0 = uint2x2(242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1911837205);
+            uint2x2 b1 = uint2x2(1507212038, 1906405167, 247693265, 293460573);
+            uint2x2 r1 = uint2x2(404625167, 5432038, 177984350, 151073767);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (1495295166);
+            uint2x2 b2 = uint2x2(873323603, 530681233, 1298102643, 2057984657);
+            uint2x2 r2 = uint2x2(621971563, 433932700, 197192523, 1495295166);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1000742091);
+            uint2x2 b3 = uint2x2(1461372131, 1859742342, 797184687, 821888842);
+            uint2x2 r3 = uint2x2(1000742091, 1000742091, 203557404, 178853249);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_plus()
+        {
+            uint2x2 a0 = uint2x2(1643476803, 907898539, 379615839, 1140483021);
+            uint2x2 r0 = uint2x2(1643476803, 907898539, 379615839, 1140483021);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint2x2 a1 = uint2x2(1735287433, 1472881565, 339091479, 401565897);
+            uint2x2 r1 = uint2x2(1735287433, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint2x2 a2 = uint2x2(1287765427, 174532915, 1864850812, 1566098441);
+            uint2x2 r2 = uint2x2(1287765427, 174532915, 1864850812, 1566098441);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint2x2 a3 = uint2x2(1145639744, 2049663954, 1723005749, 409076474);
+            uint2x2 r3 = uint2x2(1145639744, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_neg()
+        {
+            uint2x2 a0 = uint2x2(1955022112, 662160019, 370300775, 2141283773);
+            uint2x2 r0 = uint2x2(2339945184, 3632807277, 3924666521, 2153683523);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint2x2 a1 = uint2x2(1004505619, 33894270, 505708349, 1115028238);
+            uint2x2 r1 = uint2x2(3290461677, 4261073026, 3789258947, 3179939058);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint2x2 a2 = uint2x2(1636274969, 1542206286, 213087293, 243937487);
+            uint2x2 r2 = uint2x2(2658692327, 2752761010, 4081880003, 4051029809);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint2x2 a3 = uint2x2(341522275, 574159094, 1687250035, 2057919693);
+            uint2x2 r3 = uint2x2(3953445021, 3720808202, 2607717261, 2237047603);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_prefix_inc()
+        {
+            uint2x2 a0 = uint2x2(864455342, 2035793213, 1275443862, 971919915);
+            uint2x2 r0 = uint2x2(864455343, 2035793214, 1275443863, 971919916);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint2x2 a1 = uint2x2(411610189, 395072276, 115573442, 913293639);
+            uint2x2 r1 = uint2x2(411610190, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint2x2 a2 = uint2x2(432884105, 1385544935, 1835605516, 831396561);
+            uint2x2 r2 = uint2x2(432884106, 1385544936, 1835605517, 831396562);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint2x2 a3 = uint2x2(388229350, 1786514683, 993189311, 752093909);
+            uint2x2 r3 = uint2x2(388229351, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_postfix_inc()
+        {
+            uint2x2 a0 = uint2x2(1751003569, 2063707595, 1500486291, 969189211);
+            uint2x2 r0 = uint2x2(1751003569, 2063707595, 1500486291, 969189211);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint2x2 a1 = uint2x2(1007848192, 1643023524, 1190630527, 1396179607);
+            uint2x2 r1 = uint2x2(1007848192, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint2x2 a2 = uint2x2(708474528, 1524860667, 1408994706, 375284401);
+            uint2x2 r2 = uint2x2(708474528, 1524860667, 1408994706, 375284401);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint2x2 a3 = uint2x2(1580130369, 717006530, 506142468, 732199129);
+            uint2x2 r3 = uint2x2(1580130369, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_prefix_dec()
+        {
+            uint2x2 a0 = uint2x2(200904609, 871077500, 968578728, 638967721);
+            uint2x2 r0 = uint2x2(200904608, 871077499, 968578727, 638967720);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint2x2 a1 = uint2x2(1995396216, 1782514098, 1589827826, 1434377580);
+            uint2x2 r1 = uint2x2(1995396215, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint2x2 a2 = uint2x2(596759698, 1758478358, 1914114460, 71237375);
+            uint2x2 r2 = uint2x2(596759697, 1758478357, 1914114459, 71237374);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint2x2 a3 = uint2x2(389120307, 1310293956, 356565557, 18299409);
+            uint2x2 r3 = uint2x2(389120306, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_postfix_dec()
+        {
+            uint2x2 a0 = uint2x2(283970262, 1109329936, 1073216143, 649439137);
+            uint2x2 r0 = uint2x2(283970262, 1109329936, 1073216143, 649439137);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint2x2 a1 = uint2x2(1932646215, 484207852, 524156737, 691209285);
+            uint2x2 r1 = uint2x2(1932646215, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint2x2 a2 = uint2x2(2017728859, 377162390, 526366486, 1504625034);
+            uint2x2 r2 = uint2x2(2017728859, 377162390, 526366486, 1504625034);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint2x2 a3 = uint2x2(590919177, 1867810045, 2095777993, 670715645);
+            uint2x2 r3 = uint2x2(590919177, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_and_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(779935043, 1097962163, 1939593304, 800599247);
+            uint2x2 b0 = uint2x2(307705143, 1710882162, 866836769, 532490608);
+            uint2x2 r0 = uint2x2(39064835, 1097961522, 864731136, 263727168);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x2 a1 = uint2x2(952140918, 782792558, 1608557706, 396446406);
+            uint2x2 b1 = uint2x2(679371720, 1794035877, 1439832202, 519529812);
+            uint2x2 r1 = uint2x2(675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x2 a2 = uint2x2(2039894114, 1286974642, 442394124, 1759739564);
+            uint2x2 b2 = uint2x2(23633139, 1209152681, 646737179, 1255867027);
+            uint2x2 r2 = uint2x2(16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x2 a3 = uint2x2(233435438, 665207770, 1942050241, 1022352952);
+            uint2x2 b3 = uint2x2(1900854122, 413173763, 1409138251, 2087190272);
+            uint2x2 r3 = uint2x2(21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_and_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(443615469, 490057985, 2042441263, 1524760558);
+            uint b0 = (93423598);
+            uint2x2 r0 = uint2x2(1114348, 85033216, 26281518, 8488942);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x2 a1 = uint2x2(1405175110, 1941875181, 1236735839, 1365509729);
+            uint b1 = (510212004);
+            uint2x2 r1 = uint2x2(306251012, 304619940, 136386308, 274728480);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x2 a2 = uint2x2(428270198, 650270920, 1249238550, 814629680);
+            uint b2 = (607982857);
+            uint2x2 r2 = uint2x2(262144, 603983880, 3478528, 537657600);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x2 a3 = uint2x2(1862276471, 861733033, 1408932942, 957693145);
+            uint b3 = (143502472);
+            uint2x2 r3 = uint2x2(134218752, 852104, 8948744, 134556808);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint2x2 b0 = uint2x2(420346723, 562416448, 1393127318, 1560699552);
+            uint2x2 r0 = uint2x2(547170, 18752, 1074284806, 1140867104);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (851218057);
+            uint2x2 b1 = uint2x2(703880958, 1159378889, 2031211279, 1089518981);
+            uint2x2 r1 = uint2x2(548671112, 1607305, 806388233, 11570305);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (270607307);
+            uint2x2 b2 = uint2x2(1349288930, 520199596, 1763483957, 1248975349);
+            uint2x2 r2 = uint2x2(270533570, 268501384, 8449, 2163137);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (236938635);
+            uint2x2 b3 = uint2x2(185023291, 1085233038, 1845693112, 946052961);
+            uint2x2 r3 = uint2x2(168239371, 1000842, 235077768, 134415617);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_or_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1731159103, 659068416, 382702471, 1821032196);
+            uint2x2 b0 = uint2x2(1583847161, 692672727, 1161585489, 1756207130);
+            uint2x2 r0 = uint2x2(2138044159, 793370327, 1476391895, 1823457054);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x2 a1 = uint2x2(1565773438, 1004000514, 948501377, 600951835);
+            uint2x2 b1 = uint2x2(1321374429, 1287357212, 2075767170, 1273513430);
+            uint2x2 r1 = uint2x2(1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x2 a2 = uint2x2(669346222, 396691477, 2108560248, 2117522137);
+            uint2x2 b2 = uint2x2(1610830169, 1316929125, 511625048, 573925879);
+            uint2x2 r2 = uint2x2(1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x2 a3 = uint2x2(330307355, 818676817, 1774459567, 1117506257);
+            uint2x2 b3 = uint2x2(1502255628, 1841676448, 1682928938, 1115131952);
+            uint2x2 r3 = uint2x2(1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_or_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(961259683, 471103264, 1733389229, 1591585258);
+            uint b0 = (1666102508);
+            uint2x2 r0 = uint2x2(2068823279, 2136930284, 1734344685, 2145369582);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x2 a1 = uint2x2(386953869, 1048929715, 1814263250, 860336789);
+            uint b1 = (1148351449);
+            uint2x2 r1 = uint2x2(1467118557, 2130147323, 1819506651, 2004349917);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x2 a2 = uint2x2(1637162093, 774029856, 879300408, 1179087439);
+            uint b2 = (1227888278);
+            uint2x2 r2 = uint2x2(1773477631, 1865602742, 2105089982, 1333229279);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x2 a3 = uint2x2(797240690, 46921989, 1980838747, 284225881);
+            uint b3 = (1977614655);
+            uint2x2 r3 = uint2x2(2145709439, 2011953471, 2012296063, 1978724735);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint2x2 b0 = uint2x2(1212928242, 1614462616, 936937728, 764766995);
+            uint2x2 r0 = uint2x2(1213978111, 1752940445, 2145094925, 1842867999);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (306352095);
+            uint2x2 b1 = uint2x2(574719481, 1283571271, 2109131012, 979469710);
+            uint2x2 r1 = uint2x2(843288575, 1589886943, 2146881503, 979603423);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (1348323481);
+            uint2x2 b2 = uint2x2(1407542578, 697517649, 1059093741, 627815046);
+            uint2x2 r2 = uint2x2(1409150395, 2044710617, 2138963197, 1971321503);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (418822515);
+            uint2x2 b3 = uint2x2(83214352, 424663473, 447949225, 527022375);
+            uint2x2 r3 = uint2x2(486013299, 436206067, 452442619, 536852855);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_xor_wide_wide()
+        {
+            uint2x2 a0 = uint2x2(1556324760, 207002929, 1843444873, 1632079131);
+            uint2x2 b0 = uint2x2(1054997548, 1523759632, 251164872, 110472397);
+            uint2x2 r0 = uint2x2(1646419380, 1451501345, 1662567489, 1741824470);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x2 a1 = uint2x2(1460334334, 1607815585, 220623650, 38668553);
+            uint2x2 b1 = uint2x2(384031112, 1109163205, 535118981, 179106262);
+            uint2x2 r1 = uint2x2(1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x2 a2 = uint2x2(47193340, 643663548, 1371932564, 94957188);
+            uint2x2 b2 = uint2x2(1523031711, 1713313372, 1294118730, 520360641);
+            uint2x2 r2 = uint2x2(1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x2 a3 = uint2x2(700973621, 370621508, 2087573076, 351476570);
+            uint2x2 b3 = uint2x2(1040688781, 1020757245, 1143954843, 1281933464);
+            uint2x2 r3 = uint2x2(399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_xor_wide_scalar()
+        {
+            uint2x2 a0 = uint2x2(2124666952, 177397845, 574879617, 1937385541);
+            uint b0 = (493665894);
+            uint2x2 r0 = uint2x2(1674536494, 402546227, 1060063719, 1846973987);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x2 a1 = uint2x2(1136545648, 535061373, 289301586, 1305234431);
+            uint b1 = (213863690);
+            uint2x2 r1 = uint2x2(1325466234, 324742775, 495003992, 1098057461);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x2 a2 = uint2x2(353786540, 1267729267, 125659640, 1315625690);
+            uint b2 = (1308626970);
+            uint2x2 r2 = uint2x2(1528187574, 93328233, 1232959970, 6998720);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x2 a3 = uint2x2(1730088797, 375757978, 491079274, 191750702);
+            uint b3 = (116862046);
+            uint2x2 r3 = uint2x2(1642603267, 278048964, 464677428, 228249200);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint2x2 b0 = uint2x2(1077599928, 884741329, 212164516, 1585020328);
+            uint2x2 r0 = uint2x2(217506340, 2020616269, 1080648504, 313868596);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (152985454);
+            uint2x2 b1 = uint2x2(1775851275, 1416249064, 1309317737, 1773918217);
+            uint2x2 r1 = uint2x2(1623656549, 1567908230, 1192543495, 1621460839);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1509843030);
+            uint2x2 b2 = uint2x2(1206045972, 1154916424, 1947871003, 1774252400);
+            uint2x2 r2 = uint2x2(505195842, 489209886, 769935181, 809406758);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1946113778);
+            uint2x2 b3 = uint2x2(1079717492, 290620937, 1382343363, 939045099);
+            uint2x2 r3 = uint2x2(866416774, 1655558395, 563852337, 1141368345);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_left_shift()
+        {
+            uint2x2 a0 = uint2x2(197771193, 622182602, 1283988958, 1327917304);
+            int b0 = (1321149625);
+            uint2x2 r0 = uint2x2(1912602624, 2483027968, 3154116608, 4026531840);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint2x2 a1 = uint2x2(473415985, 870301196, 2058433484, 1200694230);
+            int b1 = (432425717);
+            uint2x2 r1 = uint2x2(639631360, 3246391296, 2038431744, 2059403264);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint2x2 a2 = uint2x2(1531607705, 1008296534, 1447702302, 1079614371);
+            int b2 = (1360008038);
+            uint2x2 r2 = uint2x2(3533612608, 106468736, 2458634112, 375843008);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint2x2 a3 = uint2x2(35667343, 2045594989, 2077023268, 592678686);
+            int b3 = (1664454606);
+            uint2x2 r3 = uint2x2(258195456, 1398489088, 923336704, 3821502464);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_right_shift()
+        {
+            uint2x2 a0 = uint2x2(548167301, 1161338299, 1617625829, 1860731847);
+            int b0 = (1266801540);
+            uint2x2 r0 = uint2x2(34260456, 72583643, 101101614, 116295740);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint2x2 a1 = uint2x2(713958715, 770466193, 1265099998, 572763124);
+            int b1 = (196552656);
+            uint2x2 r1 = uint2x2(10894, 11756, 19303, 8739);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint2x2 a2 = uint2x2(506619530, 2031319045, 701927980, 917785020);
+            int b2 = (426807581);
+            uint2x2 r2 = uint2x2(0, 3, 1, 1);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint2x2 a3 = uint2x2(569504877, 1102123711, 334005460, 1624751550);
+            int b3 = (185593382);
+            uint2x2 r3 = uint2x2(8898513, 17220682, 5218835, 25386742);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x2_operator_bitwise_not()
+        {
+            uint2x2 a0 = uint2x2(1403358969, 831360921, 2088190243, 976721016);
+            uint2x2 r0 = uint2x2(2891608326, 3463606374, 2206777052, 3318246279);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint2x2 a1 = uint2x2(878283189, 1935567517, 1420884856, 472965491);
+            uint2x2 r1 = uint2x2(3416684106, 2359399778, 2874082439, 3822001804);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint2x2 a2 = uint2x2(771711426, 2061524024, 753208488, 2097179283);
+            uint2x2 r2 = uint2x2(3523255869, 2233443271, 3541758807, 2197788012);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint2x2 a3 = uint2x2(1303022493, 1289372466, 1635981125, 1951018596);
+            uint2x2 r3 = uint2x2(2991944802, 3005594829, 2658986170, 2343948699);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..998b402a86a22647d8465cec1e755aa68e62181d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 103b5058df216b7488fb5bf96d18666e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..8e3912ef9c3ddf8da7c2c43e9b951867e3fdd796
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs
@@ -0,0 +1,1227 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint2x3
+    {
+        [TestCompiler]
+        public static void uint2x3_zero()
+        {
+            TestUtils.AreEqual(uint2x3.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint2x3.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint2x3.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint2x3.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint2x3.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint2x3.zero.c2.y, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_equal_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228);
+            uint2x3 b0 = uint2x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x3 a1 = uint2x3(1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            uint2x3 b1 = uint2x3(921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x3 a2 = uint2x3(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            uint2x3 b2 = uint2x3(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x3 a3 = uint2x3(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint2x3 b3 = uint2x3(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_equal_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310);
+            uint b0 = (746972502);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x3 a1 = uint2x3(1733655277, 1682018538, 795585660, 936027116, 927605411, 672785749);
+            uint b1 = (1884008277);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x3 a2 = uint2x3(1465584610, 404448210, 969511077, 442746747, 1772925698, 1884034177);
+            uint b2 = (585324157);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x3 a3 = uint2x3(451512860, 1370577708, 597010220, 1249636005, 211986678, 1305479811);
+            uint b3 = (425476075);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint2x3 b0 = uint2x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703);
+            bool2x3 r0 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1971977031);
+            uint2x3 b1 = uint2x3(47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (1737844479);
+            uint2x3 b2 = uint2x3(1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (559824292);
+            uint2x3 b3 = uint2x3(1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_not_equal_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069);
+            uint2x3 b0 = uint2x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x3 a1 = uint2x3(1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            uint2x3 b1 = uint2x3(113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x3 a2 = uint2x3(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            uint2x3 b2 = uint2x3(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x3 a3 = uint2x3(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint2x3 b3 = uint2x3(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_not_equal_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459);
+            uint b0 = (248693828);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x3 a1 = uint2x3(950170763, 2105962247, 727205263, 1640688041, 276313906, 2126300423);
+            uint b1 = (238704450);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x3 a2 = uint2x3(791998981, 1171827730, 1412347883, 1622176923, 768370497, 1072798259);
+            uint b2 = (2035077187);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x3 a3 = uint2x3(1808712713, 1582645163, 1876273820, 90244766, 30493685, 904014575);
+            uint b3 = (1497830076);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint2x3 b0 = uint2x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (364694471);
+            uint2x3 b1 = uint2x3(754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (2100802631);
+            uint2x3 b2 = uint2x3(1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1041416160);
+            uint2x3 b3 = uint2x3(356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024);
+            bool2x3 r3 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188);
+            uint2x3 b0 = uint2x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509);
+            bool2x3 r0 = bool2x3(false, true, false, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x3 a1 = uint2x3(1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            uint2x3 b1 = uint2x3(1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x3 a2 = uint2x3(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            uint2x3 b2 = uint2x3(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool2x3 r2 = bool2x3(false, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x3 a3 = uint2x3(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint2x3 b3 = uint2x3(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool2x3 r3 = bool2x3(true, true, false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203);
+            uint b0 = (1491216667);
+            bool2x3 r0 = bool2x3(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x3 a1 = uint2x3(1667165786, 840091491, 469591900, 1247103789, 315321650, 930950514);
+            uint b1 = (1615392341);
+            bool2x3 r1 = bool2x3(false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x3 a2 = uint2x3(1100560246, 908563901, 1127696709, 1286331950, 380753337, 971148054);
+            uint b2 = (933855388);
+            bool2x3 r2 = bool2x3(false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x3 a3 = uint2x3(1827886929, 1579735991, 689044913, 1960894027, 371987110, 867559111);
+            uint b3 = (1056649851);
+            bool2x3 r3 = bool2x3(false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint2x3 b0 = uint2x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157);
+            bool2x3 r0 = bool2x3(false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (445132446);
+            uint2x3 b1 = uint2x3(1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295);
+            bool2x3 r1 = bool2x3(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (2098715503);
+            uint2x3 b2 = uint2x3(608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (874278078);
+            uint2x3 b3 = uint2x3(1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911);
+            bool2x3 r3 = bool2x3(true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780);
+            uint2x3 b0 = uint2x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695);
+            bool2x3 r0 = bool2x3(true, true, false, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x3 a1 = uint2x3(241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            uint2x3 b1 = uint2x3(253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool2x3 r1 = bool2x3(false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x3 a2 = uint2x3(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            uint2x3 b2 = uint2x3(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool2x3 r2 = bool2x3(false, false, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x3 a3 = uint2x3(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint2x3 b3 = uint2x3(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool2x3 r3 = bool2x3(false, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111);
+            uint b0 = (438688675);
+            bool2x3 r0 = bool2x3(true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x3 a1 = uint2x3(1437755186, 2125058448, 304028799, 893125636, 48044515, 711945018);
+            uint b1 = (1219010035);
+            bool2x3 r1 = bool2x3(true, true, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x3 a2 = uint2x3(1035679270, 572743717, 1016617211, 2063134811, 1577403353, 64009107);
+            uint b2 = (577943770);
+            bool2x3 r2 = bool2x3(true, false, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x3 a3 = uint2x3(1462961460, 3715845, 689362811, 263973424, 1045140419, 1058332184);
+            uint b3 = (1143565920);
+            bool2x3 r3 = bool2x3(true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint2x3 b0 = uint2x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500);
+            bool2x3 r0 = bool2x3(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1443698859);
+            uint2x3 b1 = uint2x3(779217735, 691047512, 741776730, 732565983, 668302204, 1556466996);
+            bool2x3 r1 = bool2x3(true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (858599525);
+            uint2x3 b2 = uint2x3(1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345);
+            bool2x3 r2 = bool2x3(false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (299897686);
+            uint2x3 b3 = uint2x3(632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296);
+            bool2x3 r3 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_equal_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140);
+            uint2x3 b0 = uint2x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830);
+            bool2x3 r0 = bool2x3(false, true, false, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x3 a1 = uint2x3(1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            uint2x3 b1 = uint2x3(1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool2x3 r1 = bool2x3(false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x3 a2 = uint2x3(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            uint2x3 b2 = uint2x3(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool2x3 r2 = bool2x3(false, false, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x3 a3 = uint2x3(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint2x3 b3 = uint2x3(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool2x3 r3 = bool2x3(true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_equal_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951);
+            uint b0 = (1688048545);
+            bool2x3 r0 = bool2x3(false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x3 a1 = uint2x3(212084836, 1459242706, 1745758438, 532949158, 262559763, 690091301);
+            uint b1 = (58924407);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x3 a2 = uint2x3(1806172431, 1857173043, 1617221948, 2017733017, 804204255, 981729559);
+            uint b2 = (2091514001);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x3 a3 = uint2x3(2032949254, 2079225209, 26179915, 238796519, 1917813750, 1258115260);
+            uint b3 = (910922522);
+            bool2x3 r3 = bool2x3(false, false, true, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint2x3 b0 = uint2x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1678863148);
+            uint2x3 b1 = uint2x3(1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493);
+            bool2x3 r1 = bool2x3(true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (48893340);
+            uint2x3 b2 = uint2x3(66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737);
+            bool2x3 r2 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (117849810);
+            uint2x3 b3 = uint2x3(1348693584, 105489302, 259034238, 530713566, 601413850, 830430286);
+            bool2x3 r3 = bool2x3(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_equal_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687);
+            uint2x3 b0 = uint2x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472);
+            bool2x3 r0 = bool2x3(false, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x3 a1 = uint2x3(816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            uint2x3 b1 = uint2x3(290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool2x3 r1 = bool2x3(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x3 a2 = uint2x3(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            uint2x3 b2 = uint2x3(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool2x3 r2 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x3 a3 = uint2x3(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint2x3 b3 = uint2x3(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool2x3 r3 = bool2x3(false, true, false, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_equal_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132);
+            uint b0 = (1470533736);
+            bool2x3 r0 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x3 a1 = uint2x3(1186600258, 609211196, 1604309397, 829548642, 244604867, 1419295004);
+            uint b1 = (815093894);
+            bool2x3 r1 = bool2x3(true, false, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x3 a2 = uint2x3(471843809, 1460027917, 1646290021, 196833647, 1596738181, 1905036391);
+            uint b2 = (1819986195);
+            bool2x3 r2 = bool2x3(false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x3 a3 = uint2x3(1771391775, 370941146, 440219668, 1607345862, 1449142607, 1223010129);
+            uint b3 = (1584946560);
+            bool2x3 r3 = bool2x3(true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint2x3 b0 = uint2x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810);
+            bool2x3 r0 = bool2x3(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (118252990);
+            uint2x3 b1 = uint2x3(1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726);
+            bool2x3 r1 = bool2x3(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (917376832);
+            uint2x3 b2 = uint2x3(303549425, 2111728811, 945321577, 173706579, 625318949, 519443238);
+            bool2x3 r2 = bool2x3(true, false, false, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (1583588379);
+            uint2x3 b3 = uint2x3(1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308);
+            bool2x3 r3 = bool2x3(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_add_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558);
+            uint2x3 b0 = uint2x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874);
+            uint2x3 r0 = uint2x3(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x3 a1 = uint2x3(86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            uint2x3 b1 = uint2x3(1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            uint2x3 r1 = uint2x3(1721667438, 2444634161, 2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x3 a2 = uint2x3(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            uint2x3 b2 = uint2x3(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            uint2x3 r2 = uint2x3(4147356693, 749502583, 623052937, 3113339623, 2178242226, 3146426160);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x3 a3 = uint2x3(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint2x3 b3 = uint2x3(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint2x3 r3 = uint2x3(1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_add_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871);
+            uint b0 = (2124409227);
+            uint2x3 r0 = uint2x3(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x3 a1 = uint2x3(1067888129, 2003021861, 1635971971, 1160398286, 85446202, 1068152966);
+            uint b1 = (70433301);
+            uint2x3 r1 = uint2x3(1138321430, 2073455162, 1706405272, 1230831587, 155879503, 1138586267);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x3 a2 = uint2x3(1239387100, 1727477485, 1095438654, 756559204, 1818718931, 658923552);
+            uint b2 = (1497676888);
+            uint2x3 r2 = uint2x3(2737063988, 3225154373, 2593115542, 2254236092, 3316395819, 2156600440);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x3 a3 = uint2x3(1610518921, 692843300, 1068593469, 1704776233, 577782260, 736972565);
+            uint b3 = (1585755398);
+            uint2x3 r3 = uint2x3(3196274319, 2278598698, 2654348867, 3290531631, 2163537658, 2322727963);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint2x3 b0 = uint2x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201);
+            uint2x3 r0 = uint2x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (1451896269);
+            uint2x3 b1 = uint2x3(1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445);
+            uint2x3 r1 = uint2x3(3233593341, 2447928094, 3009671218, 2231671209, 2563437571, 2234942714);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1130163944);
+            uint2x3 b2 = uint2x3(288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965);
+            uint2x3 r2 = uint2x3(1418443528, 2527847805, 2766747433, 1803427283, 2599464818, 1145019909);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1116636999);
+            uint2x3 b3 = uint2x3(1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835);
+            uint2x3 r3 = uint2x3(2605500299, 2717627885, 1307288300, 2424096767, 2036722838, 3198866834);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_sub_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435);
+            uint2x3 b0 = uint2x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701);
+            uint2x3 r0 = uint2x3(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x3 a1 = uint2x3(1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            uint2x3 b1 = uint2x3(810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            uint2x3 r1 = uint2x3(570660497, 4158052549, 1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x3 a2 = uint2x3(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            uint2x3 b2 = uint2x3(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            uint2x3 r2 = uint2x3(4244761393, 3364773944, 120810088, 929308315, 3670565287, 4129068219);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x3 a3 = uint2x3(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint2x3 b3 = uint2x3(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint2x3 r3 = uint2x3(3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_sub_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714);
+            uint b0 = (462232403);
+            uint2x3 r0 = uint2x3(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x3 a1 = uint2x3(1502312334, 281174200, 87530840, 1913724431, 2041593336, 557239990);
+            uint b1 = (1451794815);
+            uint2x3 r1 = uint2x3(50517519, 3124346681, 2930703321, 461929616, 589798521, 3400412471);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x3 a2 = uint2x3(1119051448, 819090189, 816382635, 815920639, 1829033117, 1792801932);
+            uint b2 = (1590376732);
+            uint2x3 r2 = uint2x3(3823642012, 3523680753, 3520973199, 3520511203, 238656385, 202425200);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x3 a3 = uint2x3(1113440549, 1277257189, 2092779398, 642236742, 1605250794, 819644478);
+            uint b3 = (1418937976);
+            uint2x3 r3 = uint2x3(3989469869, 4153286509, 673841422, 3518266062, 186312818, 3695673798);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint2x3 b0 = uint2x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538);
+            uint2x3 r0 = uint2x3(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (939035482);
+            uint2x3 b1 = uint2x3(935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109);
+            uint2x3 r1 = uint2x3(3793205, 3444702357, 674322589, 4002146711, 3415890030, 3805566669);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (1258745460);
+            uint2x3 b2 = uint2x3(1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918);
+            uint2x3 r2 = uint2x3(181365064, 4222990037, 740633631, 291616931, 914079206, 176477542);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (907866696);
+            uint2x3 b3 = uint2x3(1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777);
+            uint2x3 r3 = uint2x3(3385948869, 447526128, 4240679494, 350753235, 3501617283, 3222735215);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mul_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440);
+            uint2x3 b0 = uint2x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665);
+            uint2x3 r0 = uint2x3(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x3 a1 = uint2x3(2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            uint2x3 b1 = uint2x3(1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            uint2x3 r1 = uint2x3(2128344329, 3700879228, 2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x3 a2 = uint2x3(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            uint2x3 b2 = uint2x3(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            uint2x3 r2 = uint2x3(990589280, 3356793344, 2953243830, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x3 a3 = uint2x3(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint2x3 b3 = uint2x3(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint2x3 r3 = uint2x3(1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mul_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909);
+            uint b0 = (1476837906);
+            uint2x3 r0 = uint2x3(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x3 a1 = uint2x3(72749215, 975743632, 573770299, 1958912969, 971327747, 1818877398);
+            uint b1 = (154616909);
+            uint2x3 r1 = uint2x3(1400257491, 7966032, 499040191, 322676597, 469811687, 3921580382);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x3 a2 = uint2x3(1324050764, 1279757657, 391009467, 1186856590, 890343818, 800117742);
+            uint b2 = (660611671);
+            uint2x3 r2 = uint2x3(645718228, 4252425023, 2516558221, 1570790978, 4161587686, 1820172770);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x3 a3 = uint2x3(606927173, 1688964615, 1439447294, 387721300, 1192501703, 1613845584);
+            uint b3 = (1338014500);
+            uint2x3 r3 = uint2x3(4040635572, 1134384636, 1352273336, 4065724368, 1766808828, 645024576);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint2x3 b0 = uint2x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654);
+            uint2x3 r0 = uint2x3(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1408757883);
+            uint2x3 b1 = uint2x3(335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231);
+            uint2x3 r1 = uint2x3(1223039806, 1995624689, 3320276176, 375843636, 858017565, 2027534157);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1336308795);
+            uint2x3 b2 = uint2x3(517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700);
+            uint2x3 r2 = uint2x3(580046269, 3297097280, 3969951899, 831291671, 3260394293, 3040627372);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (677771573);
+            uint2x3 b3 = uint2x3(2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236);
+            uint2x3 r3 = uint2x3(4169123457, 1435043573, 698030233, 9173379, 3470328490, 113055164);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_div_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154);
+            uint2x3 b0 = uint2x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613);
+            uint2x3 r0 = uint2x3(1, 0, 0, 8, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x3 a1 = uint2x3(1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            uint2x3 b1 = uint2x3(878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            uint2x3 r1 = uint2x3(2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x3 a2 = uint2x3(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            uint2x3 b2 = uint2x3(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            uint2x3 r2 = uint2x3(0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x3 a3 = uint2x3(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint2x3 b3 = uint2x3(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint2x3 r3 = uint2x3(0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_div_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408);
+            uint b0 = (947861580);
+            uint2x3 r0 = uint2x3(0, 1, 0, 1, 2, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x3 a1 = uint2x3(1349573078, 341995568, 495895326, 1515313790, 1676971657, 2131487088);
+            uint b1 = (524526253);
+            uint2x3 r1 = uint2x3(2, 0, 0, 2, 3, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x3 a2 = uint2x3(2105094094, 542666029, 1646044372, 1447236569, 107215658, 19616726);
+            uint b2 = (1017891310);
+            uint2x3 r2 = uint2x3(2, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x3 a3 = uint2x3(896899915, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864);
+            uint b3 = (707389627);
+            uint2x3 r3 = uint2x3(1, 1, 2, 2, 2, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint2x3 b0 = uint2x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283);
+            uint2x3 r0 = uint2x3(6, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (1773486938);
+            uint2x3 b1 = uint2x3(1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637);
+            uint2x3 r1 = uint2x3(1, 21, 1, 2, 38, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (396671391);
+            uint2x3 b2 = uint2x3(784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453);
+            uint2x3 r2 = uint2x3(0, 0, 0, 0, 1, 8);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (1796936382);
+            uint2x3 b3 = uint2x3(1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083);
+            uint2x3 r3 = uint2x3(1, 1, 0, 2, 1, 5);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mod_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460);
+            uint2x3 b0 = uint2x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852);
+            uint2x3 r0 = uint2x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x3 a1 = uint2x3(861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            uint2x3 b1 = uint2x3(2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            uint2x3 r1 = uint2x3(861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x3 a2 = uint2x3(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            uint2x3 b2 = uint2x3(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            uint2x3 r2 = uint2x3(137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x3 a3 = uint2x3(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint2x3 b3 = uint2x3(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint2x3 r3 = uint2x3(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mod_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208);
+            uint b0 = (883951171);
+            uint2x3 r0 = uint2x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x3 a1 = uint2x3(128329633, 896587769, 405208598, 1982762194, 959236935, 712321026);
+            uint b1 = (1464010899);
+            uint2x3 r1 = uint2x3(128329633, 896587769, 405208598, 518751295, 959236935, 712321026);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x3 a2 = uint2x3(172564850, 1085897743, 1607489717, 165478511, 647846716, 915707999);
+            uint b2 = (1540068445);
+            uint2x3 r2 = uint2x3(172564850, 1085897743, 67421272, 165478511, 647846716, 915707999);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x3 a3 = uint2x3(1602830401, 1084934806, 488509689, 2087820912, 377501313, 1778384846);
+            uint b3 = (928191283);
+            uint2x3 r3 = uint2x3(674639118, 156743523, 488509689, 231438346, 377501313, 850193563);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint2x3 b0 = uint2x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038);
+            uint2x3 r0 = uint2x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1906405167);
+            uint2x3 b1 = uint2x3(247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643);
+            uint2x3 r1 = uint2x3(172552312, 145641729, 411110001, 159757961, 314361468, 608302524);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (2057984657);
+            uint2x3 b2 = uint2x3(1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997);
+            uint2x3 r2 = uint2x3(56500475, 596612526, 198242315, 463615283, 414206973, 974791660);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (840114986);
+            uint2x3 b3 = uint2x3(1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061);
+            uint2x3 r3 = uint2x3(840114986, 224955022, 840114986, 217454, 840114986, 17224681);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_plus()
+        {
+            uint2x3 a0 = uint2x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            uint2x3 r0 = uint2x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint2x3 a1 = uint2x3(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            uint2x3 r1 = uint2x3(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint2x3 a2 = uint2x3(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            uint2x3 r2 = uint2x3(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint2x3 a3 = uint2x3(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            uint2x3 r3 = uint2x3(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_neg()
+        {
+            uint2x3 a0 = uint2x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593);
+            uint2x3 r0 = uint2x3(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint2x3 a1 = uint2x3(33894270, 1115028238, 1636274969, 694995093, 1542206286, 213087293);
+            uint2x3 r1 = uint2x3(4261073026, 3179939058, 2658692327, 3599972203, 2752761010, 4081880003);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint2x3 a2 = uint2x3(243937487, 841085242, 574159094, 1687250035, 2057919693, 1175014732);
+            uint2x3 r2 = uint2x3(4051029809, 3453882054, 3720808202, 2607717261, 2237047603, 3119952564);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint2x3 a3 = uint2x3(1259809073, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454);
+            uint2x3 r3 = uint2x3(3035158223, 3104397376, 2247011524, 2174237432, 2854192368, 2809370842);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_prefix_inc()
+        {
+            uint2x3 a0 = uint2x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725);
+            uint2x3 r0 = uint2x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint2x3 a1 = uint2x3(395072276, 913293639, 432884105, 1208161871, 1385544935, 1835605516);
+            uint2x3 r1 = uint2x3(395072277, 913293640, 432884106, 1208161872, 1385544936, 1835605517);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint2x3 a2 = uint2x3(831396561, 696475402, 1786514683, 993189311, 752093909, 1622410417);
+            uint2x3 r2 = uint2x3(831396562, 696475403, 1786514684, 993189312, 752093910, 1622410418);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint2x3 a3 = uint2x3(1398865015, 1705625817, 609525897, 172599489, 504806865, 519296647);
+            uint2x3 r3 = uint2x3(1398865016, 1705625818, 609525898, 172599490, 504806866, 519296648);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_postfix_inc()
+        {
+            uint2x3 a0 = uint2x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            uint2x3 r0 = uint2x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint2x3 a1 = uint2x3(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            uint2x3 r1 = uint2x3(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint2x3 a2 = uint2x3(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            uint2x3 r2 = uint2x3(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint2x3 a3 = uint2x3(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            uint2x3 r3 = uint2x3(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_prefix_dec()
+        {
+            uint2x3 a0 = uint2x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037);
+            uint2x3 r0 = uint2x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint2x3 a1 = uint2x3(1782514098, 1434377580, 596759698, 1699290403, 1758478358, 1914114460);
+            uint2x3 r1 = uint2x3(1782514097, 1434377579, 596759697, 1699290402, 1758478357, 1914114459);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint2x3 a2 = uint2x3(71237375, 1022184392, 1310293956, 356565557, 18299409, 906734601);
+            uint2x3 r2 = uint2x3(71237374, 1022184391, 1310293955, 356565556, 18299408, 906734600);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint2x3 a3 = uint2x3(799006218, 1040798388, 1469596990, 1719228297, 220897829, 1454322707);
+            uint2x3 r3 = uint2x3(799006217, 1040798387, 1469596989, 1719228296, 220897828, 1454322706);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_postfix_dec()
+        {
+            uint2x3 a0 = uint2x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            uint2x3 r0 = uint2x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint2x3 a1 = uint2x3(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            uint2x3 r1 = uint2x3(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint2x3 a2 = uint2x3(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            uint2x3 r2 = uint2x3(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint2x3 a3 = uint2x3(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            uint2x3 r3 = uint2x3(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_and_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558);
+            uint2x3 b0 = uint2x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877);
+            uint2x3 r0 = uint2x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x3 a1 = uint2x3(1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            uint2x3 b1 = uint2x3(1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            uint2x3 r1 = uint2x3(1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x3 a2 = uint2x3(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            uint2x3 b2 = uint2x3(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            uint2x3 r2 = uint2x3(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x3 a3 = uint2x3(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint2x3 b3 = uint2x3(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint2x3 r3 = uint2x3(168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_and_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004);
+            uint b0 = (93423598);
+            uint2x3 r0 = uint2x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x3 a1 = uint2x3(1941875181, 1365509729, 428270198, 607982857, 650270920, 1249238550);
+            uint b1 = (1236735839);
+            uint2x3 r1 = uint2x3(1102446925, 1092879937, 159777366, 3478793, 8523848, 1211438614);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x3 a2 = uint2x3(814629680, 143502472, 861733033, 1408932942, 957693145, 1567715668);
+            uint b2 = (1862276471);
+            uint2x3 r2 = uint2x3(536871216, 134218752, 587202593, 1124078662, 687871057, 1291850068);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x3 a3 = uint2x3(1102952410, 1599352836, 208656708, 1272226025, 462670926, 1817145060);
+            uint b3 = (322053683);
+            uint2x3 r3 = uint2x3(19932690, 319823872, 2228224, 51388449, 319947778, 140832);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint2x3 b0 = uint2x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958);
+            uint2x3 r0 = uint2x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1159378889);
+            uint2x3 b1 = uint2x3(2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957);
+            uint2x3 r1 = uint2x3(1091605257, 1074836865, 9161, 1074299840, 83924360, 1092133121);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1248975349);
+            uint2x3 b2 = uint2x3(236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522);
+            uint2x3 r2 = uint2x3(168903041, 167844145, 1075925380, 1241581744, 140613985, 1074872496);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (2042776519);
+            uint2x3 b3 = uint2x3(56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404);
+            uint2x3 r3 = uint2x3(21118982, 1770146496, 1769996867, 1371555910, 1229064577, 1212170948);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_or_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514);
+            uint2x3 b0 = uint2x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212);
+            uint2x3 r0 = uint2x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x3 a1 = uint2x3(948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            uint2x3 b1 = uint2x3(2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            uint2x3 r1 = uint2x3(2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x3 a2 = uint2x3(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            uint2x3 b2 = uint2x3(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            uint2x3 r2 = uint2x3(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x3 a3 = uint2x3(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint2x3 b3 = uint2x3(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint2x3 r3 = uint2x3(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_or_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449);
+            uint b0 = (1666102508);
+            uint2x3 r0 = uint2x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x3 a1 = uint2x3(1048929715, 860336789, 1637162093, 1227888278, 774029856, 879300408);
+            uint b1 = (1814263250);
+            uint2x3 r1 = uint2x3(2124903923, 2137520087, 1840741887, 1832089558, 1847850994, 2087419898);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x3 a2 = uint2x3(1179087439, 1977614655, 46921989, 1980838747, 284225881, 64304104);
+            uint b2 = (797240690);
+            uint2x3 r2 = uint2x3(1875378047, 2145709439, 802159991, 2140536699, 1073020283, 802553850);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x3 a3 = uint2x3(313591807, 1890090886, 521303722, 2021379070, 2055963359, 1511253082);
+            uint b3 = (1393862490);
+            uint2x3 r3 = uint2x3(1404413951, 1941766110, 1595340794, 2071982078, 2074060767, 1528293210);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint2x3 b0 = uint2x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481);
+            uint2x3 r0 = uint2x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (1283571271);
+            uint2x3 b1 = uint2x3(2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741);
+            uint2x3 r1 = uint2x3(2109210439, 2128723919, 1558052575, 1608908663, 1838415447, 2141322991);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (627815046);
+            uint2x3 b2 = uint2x3(418822515, 83214352, 424663473, 447949225, 527022375, 1947148461);
+            uint2x3 r2 = uint2x3(1040169975, 637530774, 1030749111, 1073462191, 1064024999, 1970254511);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (305251437);
+            uint2x3 b3 = uint2x3(1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808);
+            uint2x3 r3 = uint2x3(1526199917, 2054417661, 1593566973, 1589235437, 1391839215, 335281389);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_xor_wide_wide()
+        {
+            uint2x3 a0 = uint2x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585);
+            uint2x3 b0 = uint2x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205);
+            uint2x3 r0 = uint2x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x3 a1 = uint2x3(220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            uint2x3 b1 = uint2x3(535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            uint2x3 r1 = uint2x3(314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x3 a2 = uint2x3(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            uint2x3 b2 = uint2x3(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            uint2x3 r2 = uint2x3(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x3 a3 = uint2x3(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint2x3 b3 = uint2x3(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint2x3 r3 = uint2x3(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_xor_wide_scalar()
+        {
+            uint2x3 a0 = uint2x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690);
+            uint b0 = (493665894);
+            uint2x3 r0 = uint2x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x3 a1 = uint2x3(535061373, 1305234431, 353786540, 1308626970, 1267729267, 125659640);
+            uint b1 = (289301586);
+            uint2x3 r1 = uint2x3(249169711, 1559375789, 69746430, 1597928520, 1521379105, 373493162);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x3 a2 = uint2x3(1315625690, 116862046, 375757978, 491079274, 191750702, 187129429);
+            uint b2 = (1730088797);
+            uint2x3 r2 = uint2x3(695588231, 1642603267, 1903858631, 2052737335, 1819471219, 1815630088);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x3 a3 = uint2x3(967051293, 653124416, 788984, 1479174924, 1680011736, 447453839);
+            uint b3 = (549951551);
+            uint2x3 r3 = uint2x3(425955362, 103447423, 550212039, 2028860211, 1155885543, 980157104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint2x3 b0 = uint2x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275);
+            uint2x3 r0 = uint2x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1416249064);
+            uint2x3 b1 = uint2x3(1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003);
+            uint2x3 r1 = uint2x3(442541185, 1037166305, 227827390, 327742460, 280796832, 544217587);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1774252400);
+            uint2x3 b2 = uint2x3(1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053);
+            uint2x3 r2 = uint2x3(440379266, 698081028, 2022864761, 1000608691, 1580745115, 667852101);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (221134131);
+            uint2x3 b3 = uint2x3(885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520);
+            uint2x3 r3 = uint2x3(971170309, 693458543, 113181510, 1584258954, 790500762, 1630705027);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_left_shift()
+        {
+            uint2x3 a0 = uint2x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717);
+            int b0 = (1321149625);
+            uint2x3 r0 = uint2x3(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint2x3 a1 = uint2x3(870301196, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302);
+            int b1 = (2058433484);
+            uint2x3 r1 = uint2x3(4225810432, 306012160, 2812907520, 20340736, 2519031808, 2733760512);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint2x3 a2 = uint2x3(1079614371, 1664454606, 2045594989, 2077023268, 592678686, 297755411);
+            int b2 = (35667343);
+            uint2x3 r2 = uint2x3(3453059072, 3353804800, 2796978176, 1846673408, 3348037632, 2978578432);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint2x3 a3 = uint2x3(1722762487, 37265945, 997793693, 1521705181, 263886278, 221147365);
+            int b3 = (1161625759);
+            uint2x3 r3 = uint2x3(2147483648, 2147483648, 2147483648, 2147483648, 0, 2147483648);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_right_shift()
+        {
+            uint2x3 a0 = uint2x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656);
+            int b0 = (1266801540);
+            uint2x3 r0 = uint2x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint2x3 a1 = uint2x3(770466193, 572763124, 506619530, 426807581, 2031319045, 701927980);
+            int b1 = (1265099998);
+            uint2x3 r1 = uint2x3(0, 0, 0, 0, 1, 0);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint2x3 a2 = uint2x3(917785020, 185593382, 1102123711, 334005460, 1624751550, 280138733);
+            int b2 = (569504877);
+            uint2x3 r2 = uint2x3(112034, 22655, 134536, 40772, 198333, 34196);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint2x3 a3 = uint2x3(1598620011, 736389149, 1279158873, 408822762, 763607760, 348013684);
+            int b3 = (1840564178);
+            uint2x3 r3 = uint2x3(6098, 2809, 4879, 1559, 2912, 1327);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x3_operator_bitwise_not()
+        {
+            uint2x3 a0 = uint2x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339);
+            uint2x3 r0 = uint2x3(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint2x3 a1 = uint2x3(1935567517, 472965491, 771711426, 627580960, 2061524024, 753208488);
+            uint2x3 r1 = uint2x3(2359399778, 3822001804, 3523255869, 3667386335, 2233443271, 3541758807);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint2x3 a2 = uint2x3(2097179283, 664744603, 1289372466, 1635981125, 1951018596, 1545651937);
+            uint2x3 r2 = uint2x3(2197788012, 3630222692, 3005594829, 2658986170, 2343948699, 2749315358);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint2x3 a3 = uint2x3(717936457, 1342785385, 869629475, 2045854321, 1282546942, 1562433528);
+            uint2x3 r3 = uint2x3(3577030838, 2952181910, 3425337820, 2249112974, 3012420353, 2732533767);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..cdbcfb3da1405222e87b47349363d6e5a319fff8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 957fb6da77f246049898f0ef4647166d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..b9bbbe6682f64d8e80a6b63a73502ba0c617c3fc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs
@@ -0,0 +1,1229 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint2x4
+    {
+        [TestCompiler]
+        public static void uint2x4_zero()
+        {
+            TestUtils.AreEqual(uint2x4.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c2.y, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c3.x, 0u);
+            TestUtils.AreEqual(uint2x4.zero.c3.y, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_equal_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370);
+            uint2x4 b0 = uint2x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x4 a1 = uint2x4(1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            uint2x4 b1 = uint2x4(1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x4 a2 = uint2x4(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint2x4 b2 = uint2x4(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x4 a3 = uint2x4(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            uint2x4 b3 = uint2x4(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_equal_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277);
+            uint b0 = (746972502);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint2x4 a1 = uint2x4(1682018538, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077);
+            uint b1 = (795585660);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint2x4 a2 = uint2x4(442746747, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678);
+            uint b2 = (1772925698);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint2x4 a3 = uint2x4(1305479811, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832);
+            uint b3 = (255635293);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint2x4 b0 = uint2x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124);
+            bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1061805787);
+            uint2x4 b1 = uint2x4(1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (2003197687);
+            uint2x4 b2 = uint2x4(1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (367814403);
+            uint2x4 b3 = uint2x4(1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_not_equal_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646);
+            uint2x4 b0 = uint2x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x4 a1 = uint2x4(1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            uint2x4 b1 = uint2x4(1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x4 a2 = uint2x4(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint2x4 b2 = uint2x4(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x4 a3 = uint2x4(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            uint2x4 b3 = uint2x4(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_not_equal_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450);
+            uint b0 = (248693828);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint2x4 a1 = uint2x4(2105962247, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883);
+            uint b1 = (727205263);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint2x4 a2 = uint2x4(1622176923, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685);
+            uint b2 = (768370497);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint2x4 a3 = uint2x4(904014575, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907);
+            uint b3 = (384643370);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint2x4 b0 = uint2x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (124108032);
+            uint2x4 b1 = uint2x4(1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (266984506);
+            uint2x4 b2 = uint2x4(2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350);
+            bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (572038024);
+            uint2x4 b3 = uint2x4(1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973);
+            uint2x4 b0 = uint2x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202);
+            bool2x4 r0 = bool2x4(false, true, false, false, false, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x4 a1 = uint2x4(928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            uint2x4 b1 = uint2x4(2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool2x4 r1 = bool2x4(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x4 a2 = uint2x4(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint2x4 b2 = uint2x4(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool2x4 r2 = bool2x4(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x4 a3 = uint2x4(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            uint2x4 b3 = uint2x4(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool2x4 r3 = bool2x4(false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341);
+            uint b0 = (1491216667);
+            bool2x4 r0 = bool2x4(true, true, true, false, true, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint2x4 a1 = uint2x4(840091491, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709);
+            uint b1 = (469591900);
+            bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint2x4 a2 = uint2x4(1286331950, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110);
+            uint b2 = (380753337);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint2x4 a3 = uint2x4(867559111, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996);
+            uint b3 = (1703747625);
+            bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint2x4 b0 = uint2x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255);
+            bool2x4 r0 = bool2x4(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (111349251);
+            uint2x4 b1 = uint2x4(1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507);
+            bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1027318999);
+            uint2x4 b2 = uint2x4(146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400);
+            bool2x4 r2 = bool2x4(false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (1329939911);
+            uint2x4 b3 = uint2x4(1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550);
+            uint2x4 b0 = uint2x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742);
+            bool2x4 r0 = bool2x4(true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x4 a1 = uint2x4(2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            uint2x4 b1 = uint2x4(910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool2x4 r1 = bool2x4(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x4 a2 = uint2x4(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint2x4 b2 = uint2x4(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x4 a3 = uint2x4(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            uint2x4 b3 = uint2x4(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool2x4 r3 = bool2x4(true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035);
+            uint b0 = (438688675);
+            bool2x4 r0 = bool2x4(true, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint2x4 a1 = uint2x4(2125058448, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211);
+            uint b1 = (304028799);
+            bool2x4 r1 = bool2x4(true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint2x4 a2 = uint2x4(2063134811, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419);
+            uint b2 = (1577403353);
+            bool2x4 r2 = bool2x4(true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint2x4 a3 = uint2x4(1058332184, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708);
+            uint b3 = (524569092);
+            bool2x4 r3 = bool2x4(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint2x4 b0 = uint2x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735);
+            bool2x4 r0 = bool2x4(true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (691047512);
+            uint2x4 b1 = uint2x4(741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621);
+            bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1023307544);
+            uint2x4 b2 = uint2x4(1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900);
+            bool2x4 r2 = bool2x4(false, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (315569296);
+            uint2x4 b3 = uint2x4(292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844);
+            bool2x4 r3 = bool2x4(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_equal_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394);
+            uint2x4 b0 = uint2x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595);
+            bool2x4 r0 = bool2x4(false, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x4 a1 = uint2x4(117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            uint2x4 b1 = uint2x4(1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool2x4 r1 = bool2x4(true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x4 a2 = uint2x4(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint2x4 b2 = uint2x4(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool2x4 r2 = bool2x4(true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x4 a3 = uint2x4(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            uint2x4 b3 = uint2x4(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool2x4 r3 = bool2x4(false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_equal_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407);
+            uint b0 = (1688048545);
+            bool2x4 r0 = bool2x4(false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint2x4 a1 = uint2x4(1459242706, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948);
+            uint b1 = (1745758438);
+            bool2x4 r1 = bool2x4(true, true, true, true, false, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint2x4 a2 = uint2x4(2017733017, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750);
+            uint b2 = (804204255);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint2x4 a3 = uint2x4(1258115260, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122);
+            uint b3 = (20607406);
+            bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint2x4 b0 = uint2x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (762067160);
+            uint2x4 b1 = uint2x4(11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309);
+            bool2x4 r1 = bool2x4(false, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (861890786);
+            uint2x4 b2 = uint2x4(478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850);
+            bool2x4 r2 = bool2x4(false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (830430286);
+            uint2x4 b3 = uint2x4(145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788);
+            bool2x4 r3 = bool2x4(false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_equal_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546);
+            uint2x4 b0 = uint2x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862);
+            bool2x4 r0 = bool2x4(false, false, true, false, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x4 a1 = uint2x4(1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            uint2x4 b1 = uint2x4(396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool2x4 r1 = bool2x4(true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x4 a2 = uint2x4(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint2x4 b2 = uint2x4(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool2x4 r2 = bool2x4(false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x4 a3 = uint2x4(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            uint2x4 b3 = uint2x4(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool2x4 r3 = bool2x4(false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_equal_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894);
+            uint b0 = (1470533736);
+            bool2x4 r0 = bool2x4(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint2x4 a1 = uint2x4(609211196, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021);
+            uint b1 = (1604309397);
+            bool2x4 r1 = bool2x4(false, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint2x4 a2 = uint2x4(196833647, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607);
+            uint b2 = (1596738181);
+            bool2x4 r2 = bool2x4(false, true, true, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint2x4 a3 = uint2x4(1223010129, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090);
+            uint b3 = (379014762);
+            bool2x4 r3 = bool2x4(true, true, false, true, true, false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint2x4 b0 = uint2x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090);
+            bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (1240253990);
+            uint2x4 b1 = uint2x4(1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577);
+            bool2x4 r1 = bool2x4(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (173706579);
+            uint2x4 b2 = uint2x4(625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452);
+            bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (233894308);
+            uint2x4 b3 = uint2x4(479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835);
+            bool2x4 r3 = bool2x4(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_add_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721);
+            uint2x4 b0 = uint2x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440);
+            uint2x4 r0 = uint2x4(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x4 a1 = uint2x4(698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            uint2x4 b1 = uint2x4(1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            uint2x4 r1 = uint2x4(2285462935, 1101613923, 3495777492, 1384643660, 4147356693, 749502583, 623052937, 3113339623);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x4 a2 = uint2x4(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint2x4 b2 = uint2x4(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint2x4 r2 = uint2x4(2178242226, 3146426160, 1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x4 a3 = uint2x4(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            uint2x4 b3 = uint2x4(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            uint2x4 r3 = uint2x4(3048865720, 2901392143, 1940611170, 1099044556, 2362767916, 1285092016, 2641863205, 3757383291);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_add_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301);
+            uint b0 = (2124409227);
+            uint2x4 r0 = uint2x4(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint2x4 a1 = uint2x4(2003021861, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654);
+            uint b1 = (1635971971);
+            uint2x4 r1 = uint2x4(3638993832, 2796370257, 1721418173, 2704124937, 2875359071, 3133648859, 3363449456, 2731410625);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint2x4 a2 = uint2x4(756559204, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260);
+            uint b2 = (1818718931);
+            uint2x4 r2 = uint2x4(2575278135, 2477642483, 3429237852, 3404474329, 2511562231, 2887312400, 3523495164, 2396501191);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint2x4 a3 = uint2x4(736972565, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516);
+            uint b3 = (711894571);
+            uint2x4 r3 = uint2x4(1448867136, 1276152010, 2763630854, 2284732268, 2339901116, 2567594834, 1368643353, 984669087);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint2x4 b0 = uint2x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072);
+            uint2x4 r0 = uint2x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (996031825);
+            uint2x4 b1 = uint2x4(1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489);
+            uint2x4 r1 = uint2x4(2553806774, 1775806765, 2107573127, 1779078270, 2126195769, 1284311409, 2393715686, 2632615314);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (673263339);
+            uint2x4 b2 = uint2x4(1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839);
+            uint2x4 r2 = uint2x4(2142564213, 688119304, 1789900338, 2162126639, 2274254225, 863914640, 1980723107, 1593349178);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (2082229835);
+            uint2x4 b3 = uint2x4(1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222);
+            uint2x4 r3 = uint2x4(4074635409, 3296154293, 2588071287, 3063650997, 3570567534, 3196056475, 3888376343, 3924021057);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_sub_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138);
+            uint2x4 b0 = uint2x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885);
+            uint2x4 r0 = uint2x4(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x4 a1 = uint2x4(1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            uint2x4 b1 = uint2x4(71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            uint2x4 r1 = uint2x4(1234495882, 3456019244, 3562788131, 3413504982, 4244761393, 3364773944, 120810088, 929308315);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x4 a2 = uint2x4(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint2x4 b2 = uint2x4(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint2x4 r2 = uint2x4(3670565287, 4129068219, 3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x4 a3 = uint2x4(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            uint2x4 b3 = uint2x4(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            uint2x4 r3 = uint2x4(4111227161, 972642792, 3745373142, 2826807304, 3564332942, 1218011798, 1846728662, 3739059778);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_sub_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815);
+            uint b0 = (462232403);
+            uint2x4 r0 = uint2x4(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint2x4 a1 = uint2x4(281174200, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635);
+            uint b1 = (87530840);
+            uint2x4 r1 = uint2x4(193643360, 1826193591, 1954062496, 469709150, 1031520608, 1502845892, 731559349, 728851795);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint2x4 a2 = uint2x4(815920639, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794);
+            uint b2 = (1829033117);
+            uint2x4 r2 = uint2x4(3281854818, 4258736111, 3579374728, 3884872155, 3743191368, 263746281, 3108170921, 4071184973);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint2x4 a3 = uint2x4(819644478, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500);
+            uint b3 = (1468003019);
+            uint2x4 r3 = uint2x4(3646608755, 2955267463, 3380458534, 3844091248, 531741763, 549269739, 349988745, 4107949777);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint2x4 b0 = uint2x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277);
+            uint2x4 r0 = uint2x4(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (1789300421);
+            uint2x4 b1 = uint2x4(264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829);
+            uint2x4 r1 = uint2x4(1524587528, 557444354, 4266154969, 360864312, 530554961, 711920025, 458577702, 1271188592);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (967128529);
+            uint2x4 b2 = uint2x4(344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709);
+            uint2x4 r2 = uint2x4(622462275, 4179827907, 59261833, 3445210702, 506787961, 4974031, 410015068, 3560879116);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1980098777);
+            uint2x4 b3 = uint2x4(730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041);
+            uint2x4 r3 = uint2x4(1250038225, 535700950, 1126528221, 1841262345, 966908349, 1262009247, 1473341387, 763650736);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mul_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069);
+            uint2x4 b0 = uint2x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980);
+            uint2x4 r0 = uint2x4(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x4 a1 = uint2x4(571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            uint2x4 b1 = uint2x4(1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            uint2x4 r1 = uint2x4(2640799263, 2093463192, 3087460678, 3161406466, 990589280, 3356793344, 2953243830, 1156600361);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x4 a2 = uint2x4(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint2x4 b2 = uint2x4(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint2x4 r2 = uint2x4(649177976, 678952165, 1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x4 a3 = uint2x4(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            uint2x4 b3 = uint2x4(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            uint2x4 r3 = uint2x4(1891467339, 335415735, 1128927428, 2638713520, 2861115658, 479369680, 3928339236, 4044803354);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mul_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909);
+            uint b0 = (1476837906);
+            uint2x4 r0 = uint2x4(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint2x4 a1 = uint2x4(975743632, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467);
+            uint b1 = (573770299);
+            uint2x4 r1 = uint2x4(414773040, 3595344211, 1045098929, 3165813842, 1954692228, 970215437, 1522404739, 631100697);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint2x4 a2 = uint2x4(1186856590, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703);
+            uint b2 = (890343818);
+            uint2x4 r2 = uint2x4(218605196, 908725324, 3489887282, 2766521704, 1365477062, 1262261996, 2040090952, 691203142);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint2x4 a3 = uint2x4(1613845584, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051);
+            uint b3 = (76318055);
+            uint2x4 r3 = uint2x4(2959506480, 1256424448, 3749667707, 628661398, 357366566, 753276674, 2132219401, 3469671949);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint2x4 b0 = uint2x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146);
+            uint2x4 r0 = uint2x4(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (2105124483);
+            uint2x4 b1 = uint2x4(1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225);
+            uint2x4 r1 = uint2x4(3266048080, 2084093460, 1286996821, 910923781, 1886305329, 3255007413, 644799552, 1815059427);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (994616533);
+            uint2x4 b2 = uint2x4(1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330);
+            uint2x4 r2 = uint2x4(585859259, 2021158292, 1046891801, 2353145761, 3556190869, 2579715257, 4134395107, 1259643370);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (1186460236);
+            uint2x4 b3 = uint2x4(657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873);
+            uint2x4 r3 = uint2x4(3393334220, 3415667152, 1278776548, 1761940324, 3619679884, 2049744268, 3919669496, 2350571308);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_div_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739);
+            uint2x4 b0 = uint2x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678);
+            uint2x4 r0 = uint2x4(1, 0, 0, 8, 0, 0, 2, 7);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x4 a1 = uint2x4(499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            uint2x4 b1 = uint2x4(2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            uint2x4 r1 = uint2x4(0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x4 a2 = uint2x4(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint2x4 b2 = uint2x4(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint2x4 r2 = uint2x4(1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x4 a3 = uint2x4(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            uint2x4 b3 = uint2x4(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            uint2x4 r3 = uint2x4(2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_div_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253);
+            uint b0 = (947861580);
+            uint2x4 r0 = uint2x4(0, 1, 0, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint2x4 a1 = uint2x4(341995568, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372);
+            uint b1 = (495895326);
+            uint2x4 r1 = uint2x4(0, 3, 3, 4, 4, 2, 1, 3);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint2x4 a2 = uint2x4(1447236569, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924);
+            uint b2 = (107215658);
+            uint2x4 r2 = uint2x4(13, 0, 8, 6, 11, 13, 16, 17);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint2x4 a3 = uint2x4(1244966864, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348);
+            uint b3 = (1200843642);
+            uint2x4 r3 = uint2x4(1, 0, 1, 1, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint2x4 b0 = uint2x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032);
+            uint2x4 r0 = uint2x4(6, 0, 0, 0, 2, 0, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (81831373);
+            uint2x4 b1 = uint2x4(1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859);
+            uint2x4 r1 = uint2x4(0, 0, 1, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1653451772);
+            uint2x4 b2 = uint2x4(270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890);
+            uint2x4 r2 = uint2x4(6, 33, 0, 1, 1, 0, 2, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (351914083);
+            uint2x4 b3 = uint2x4(131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708);
+            uint2x4 r3 = uint2x4(2, 0, 0, 0, 1, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mod_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532);
+            uint2x4 b0 = uint2x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806);
+            uint2x4 r0 = uint2x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x4 a1 = uint2x4(778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            uint2x4 b1 = uint2x4(769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            uint2x4 r1 = uint2x4(9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x4 a2 = uint2x4(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint2x4 b2 = uint2x4(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint2x4 r2 = uint2x4(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x4 a3 = uint2x4(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            uint2x4 b3 = uint2x4(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            uint2x4 r3 = uint2x4(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mod_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899);
+            uint b0 = (883951171);
+            uint2x4 r0 = uint2x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint2x4 a1 = uint2x4(896587769, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717);
+            uint b1 = (405208598);
+            uint2x4 r1 = uint2x4(86170573, 361927802, 148819739, 307112428, 172564850, 324442651, 275480547, 391863923);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint2x4 a2 = uint2x4(165478511, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313);
+            uint b2 = (647846716);
+            uint2x4 r2 = uint2x4(165478511, 267861283, 307136969, 280344567, 437088090, 488509689, 144280764, 377501313);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint2x4 a3 = uint2x4(1778384846, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942);
+            uint b3 = (1216011754);
+            uint2x4 r3 = uint2x4(562373092, 812183417, 1153802502, 426660116, 708698988, 665297470, 352079071, 834971188);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint2x4 b0 = uint2x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265);
+            uint2x4 r0 = uint2x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (293460573);
+            uint2x4 b1 = uint2x4(1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342);
+            uint2x4 r1 = uint2x4(293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (797184687);
+            uint2x4 b2 = uint2x4(821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318);
+            uint2x4 r2 = uint2x4(797184687, 797184687, 797184687, 797184687, 182024723, 797184687, 1919391, 797184687);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (164578061);
+            uint2x4 b3 = uint2x4(730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733);
+            uint2x4 r3 = uint2x4(164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_plus()
+        {
+            uint2x4 a0 = uint2x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            uint2x4 r0 = uint2x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint2x4 a1 = uint2x4(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            uint2x4 r1 = uint2x4(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint2x4 a2 = uint2x4(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            uint2x4 r2 = uint2x4(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint2x4 a3 = uint2x4(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            uint2x4 r3 = uint2x4(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_neg()
+        {
+            uint2x4 a0 = uint2x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349);
+            uint2x4 r0 = uint2x4(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint2x4 a1 = uint2x4(1115028238, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094);
+            uint2x4 r1 = uint2x4(3179939058, 3599972203, 2752761010, 4081880003, 4051029809, 3953445021, 3453882054, 3720808202);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint2x4 a2 = uint2x4(1687250035, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928);
+            uint2x4 r2 = uint2x4(2607717261, 3119952564, 3035158223, 3082501970, 3104397376, 2247011524, 2174237432, 2854192368);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint2x4 a3 = uint2x4(1485596454, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098);
+            uint2x4 r3 = uint2x4(2809370842, 2907365578, 2549315298, 3975851670, 3175007490, 3555835012, 2340793982, 2585110198);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_prefix_inc()
+        {
+            uint2x4 a0 = uint2x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442);
+            uint2x4 r0 = uint2x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint2x4 a1 = uint2x4(913293639, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683);
+            uint2x4 r1 = uint2x4(913293640, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint2x4 a2 = uint2x4(993189311, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865);
+            uint2x4 r2 = uint2x4(993189312, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint2x4 a3 = uint2x4(519296647, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208);
+            uint2x4 r3 = uint2x4(519296648, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_postfix_inc()
+        {
+            uint2x4 a0 = uint2x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            uint2x4 r0 = uint2x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint2x4 a1 = uint2x4(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            uint2x4 r1 = uint2x4(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint2x4 a2 = uint2x4(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            uint2x4 r2 = uint2x4(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint2x4 a3 = uint2x4(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            uint2x4 r3 = uint2x4(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_prefix_dec()
+        {
+            uint2x4 a0 = uint2x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826);
+            uint2x4 r0 = uint2x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint2x4 a1 = uint2x4(1434377580, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956);
+            uint2x4 r1 = uint2x4(1434377579, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint2x4 a2 = uint2x4(356565557, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829);
+            uint2x4 r2 = uint2x4(356565556, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint2x4 a3 = uint2x4(1454322707, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343);
+            uint2x4 r3 = uint2x4(1454322706, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_postfix_dec()
+        {
+            uint2x4 a0 = uint2x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            uint2x4 r0 = uint2x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint2x4 a1 = uint2x4(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            uint2x4 r1 = uint2x4(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint2x4 a2 = uint2x4(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            uint2x4 r2 = uint2x4(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint2x4 a3 = uint2x4(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            uint2x4 r3 = uint2x4(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_and_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406);
+            uint2x4 b0 = uint2x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812);
+            uint2x4 r0 = uint2x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x4 a1 = uint2x4(2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            uint2x4 b1 = uint2x4(23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            uint2x4 r1 = uint2x4(16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x4 a2 = uint2x4(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint2x4 b2 = uint2x4(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint2x4 r2 = uint2x4(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x4 a3 = uint2x4(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            uint2x4 b3 = uint2x4(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            uint2x4 r3 = uint2x4(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_and_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839);
+            uint b0 = (93423598);
+            uint2x4 r0 = uint2x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint2x4 a1 = uint2x4(1365509729, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033);
+            uint b1 = (428270198);
+            uint2x4 r1 = uint2x4(285475424, 262144, 8536128, 134529558, 277234224, 150995062, 142909440, 285474848);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint2x4 a2 = uint2x4(1408932942, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926);
+            uint b2 = (957693145);
+            uint2x4 r2 = uint2x4(286268488, 420556880, 18167000, 286270481, 420753408, 134551616, 152314057, 420547656);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint2x4 a3 = uint2x4(1817145060, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525);
+            uint b3 = (1466722981);
+            uint2x4 r3 = uint2x4(1145858724, 1145069572, 273443365, 101460005, 1093403136, 524420, 335806629, 1142948357);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint2x4 b0 = uint2x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279);
+            uint2x4 r0 = uint2x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1089518981);
+            uint2x4 b1 = uint2x4(270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038);
+            uint2x4 r1 = uint2x4(2105729, 1080066432, 40324, 1074831621, 1081121157, 1058177, 14593, 1084233092);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1845693112);
+            uint2x4 b2 = uint2x4(946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417);
+            uint2x4 r2 = uint2x4(671287840, 1141047992, 1744964224, 33751056, 1744964256, 1845559864, 1140852752, 1208158384);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1214109404);
+            uint2x4 b3 = uint2x4(2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506);
+            uint2x4 r3 = uint2x4(16988, 1208799884, 1074321052, 1209303624, 1115840, 1213727936, 1610312, 1078218760);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_or_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835);
+            uint2x4 b0 = uint2x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430);
+            uint2x4 r0 = uint2x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x4 a1 = uint2x4(669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            uint2x4 b1 = uint2x4(1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            uint2x4 r1 = uint2x4(1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x4 a2 = uint2x4(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint2x4 b2 = uint2x4(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint2x4 r2 = uint2x4(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x4 a3 = uint2x4(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            uint2x4 b3 = uint2x4(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            uint2x4 r3 = uint2x4(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_or_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250);
+            uint b0 = (1666102508);
+            uint2x4 r0 = uint2x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint2x4 a1 = uint2x4(860336789, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989);
+            uint b1 = (1637162093);
+            uint2x4 r1 = uint2x4(1943518973, 1773477631, 1874321005, 1979522941, 1742175855, 1872100735, 1978998143, 1675623789);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint2x4 a2 = uint2x4(1980838747, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359);
+            uint b2 = (284225881);
+            uint2x4 r2 = uint2x4(1995567963, 334885881, 317847551, 1408563035, 1895366623, 536016891, 2029779967, 2063332319);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint2x4 a3 = uint2x4(1511253082, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895);
+            uint b3 = (1775629833);
+            uint2x4 r3 = uint2x4(2077750875, 1843265467, 1775761279, 2111176313, 2046817999, 2113404623, 1778251405, 2077753039);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint2x4 b0 = uint2x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012);
+            uint2x4 r0 = uint2x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (979469710);
+            uint2x4 b1 = uint2x4(1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473);
+            uint2x4 r1 = uint2x4(2055064991, 2078664126, 1005832159, 1063386607, 1064023950, 989314559, 1056294302, 997187007);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (447949225);
+            uint2x4 b2 = uint2x4(527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150);
+            uint2x4 r2 = uint2x4(536590767, 2126457261, 447999469, 1526184941, 2062773753, 1593519101, 1589357545, 1526197231);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (298563808);
+            uint2x4 b3 = uint2x4(2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556);
+            uint2x4 r3 = uint2x4(2078276845, 872414207, 938213110, 1945092072, 1375468774, 838844392, 1004273386, 836763636);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_xor_wide_wide()
+        {
+            uint2x4 a0 = uint2x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553);
+            uint2x4 b0 = uint2x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262);
+            uint2x4 r0 = uint2x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x4 a1 = uint2x4(47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            uint2x4 b1 = uint2x4(1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            uint2x4 r1 = uint2x4(1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x4 a2 = uint2x4(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint2x4 b2 = uint2x4(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint2x4 r2 = uint2x4(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x4 a3 = uint2x4(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            uint2x4 b3 = uint2x4(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            uint2x4 r3 = uint2x4(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_xor_wide_scalar()
+        {
+            uint2x4 a0 = uint2x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586);
+            uint b0 = (493665894);
+            uint2x4 r0 = uint2x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint2x4 a1 = uint2x4(1305234431, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978);
+            uint b1 = (353786540);
+            uint2x4 r1 = uint2x4(1490686291, 1528187574, 1585863135, 309015380, 1534886006, 1913214449, 333543154, 57919030);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint2x4 a2 = uint2x4(491079274, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736);
+            uint b2 = (191750702);
+            uint2x4 r2 = uint2x4(371762244, 4897915, 852093491, 732592657, 763363694, 190966742, 1397197090, 1867453430);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint2x4 a3 = uint2x4(447453839, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291);
+            uint b3 = (890841598);
+            uint2x4 r3 = uint2x4(800240497, 610664066, 711808497, 714187902, 1735978412, 1929239075, 171965729, 427463573);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint2x4 b0 = uint2x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737);
+            uint2x4 r0 = uint2x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1773918217);
+            uint2x4 b1 = uint2x4(1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937);
+            uint2x4 r1 = uint2x4(809875551, 777590045, 762148929, 497155858, 8071545, 440700667, 702609021, 2028559872);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1382343363);
+            uint2x4 b2 = uint2x4(939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481);
+            uint2x4 r2 = uint2x4(1704743464, 476745462, 1598742512, 1722301941, 1981778335, 1509285046, 19333242, 1884605034);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1813817520);
+            uint2x4 b3 = uint2x4(86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759);
+            uint2x4 r3 = uint2x4(1765145501, 465338881, 961174309, 1508358725, 916626445, 1734574159, 1183306712, 2052237431);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_left_shift()
+        {
+            uint2x4 a0 = uint2x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484);
+            int b0 = (1321149625);
+            uint2x4 r0 = uint2x4(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint2x4 a1 = uint2x4(1200694230, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989);
+            int b1 = (1531607705);
+            uint2x4 r1 = uint2x4(2885681152, 3422552064, 2885681152, 1006632960, 1174405120, 503316480, 2617245696, 3657433088);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint2x4 a2 = uint2x4(2077023268, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278);
+            int b2 = (592678686);
+            uint2x4 r2 = uint2x4(0, 3221225472, 3221225472, 3221225472, 1073741824, 1073741824, 1073741824, 2147483648);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint2x4 a3 = uint2x4(221147365, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688);
+            int b3 = (2084190583);
+            uint2x4 r3 = uint2x4(1920991232, 2952790016, 3690987520, 4160749568, 3489660928, 3984588800, 109051904, 1207959552);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_right_shift()
+        {
+            uint2x4 a0 = uint2x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998);
+            int b0 = (1266801540);
+            uint2x4 r0 = uint2x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint2x4 a1 = uint2x4(572763124, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711);
+            int b1 = (506619530);
+            uint2x4 r1 = uint2x4(559338, 416804, 1983710, 685476, 896274, 556157, 181243, 1076292);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint2x4 a2 = uint2x4(334005460, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760);
+            int b2 = (1624751550);
+            uint2x4 r2 = uint2x4(0, 0, 1, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint2x4 a3 = uint2x4(348013684, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476);
+            int b3 = (1568185874);
+            uint2x4 r3 = uint2x4(1327, 2953, 6054, 2289, 112, 7175, 1343, 4442);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint2x4_operator_bitwise_not()
+        {
+            uint2x4 a0 = uint2x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856);
+            uint2x4 r0 = uint2x4(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint2x4 a1 = uint2x4(472965491, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466);
+            uint2x4 r1 = uint2x4(3822001804, 3667386335, 2233443271, 3541758807, 2197788012, 2991944802, 3630222692, 3005594829);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint2x4 a2 = uint2x4(1635981125, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942);
+            uint2x4 r2 = uint2x4(2658986170, 2749315358, 3577030838, 3010462608, 2952181910, 3425337820, 2249112974, 3012420353);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint2x4 a3 = uint2x4(1562433528, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039);
+            uint2x4 r3 = uint2x4(2732533767, 2558396580, 3786061237, 2234214415, 2427548539, 3906437021, 3599787443, 2528029256);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..7ef0b944e5a93cf320b624304f5283cab1e6366e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint2x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 27ff3548fed6aa741b4d1d7cb7a291e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..bc4bb8ab45f24bd4dfe77d351895f11ed7120ca9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs
@@ -0,0 +1,1346 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint3
+    {
+        [TestCompiler]
+        public static void uint3_zero()
+        {
+            TestUtils.AreEqual(uint3.zero.x, 0u);
+            TestUtils.AreEqual(uint3.zero.y, 0u);
+            TestUtils.AreEqual(uint3.zero.z, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint3_constructor()
+        {
+            uint3 a = new uint3(1, 2, 3);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+        }
+
+        [TestCompiler]
+        public static void uint3_scalar_constructor()
+        {
+            uint3 a = new uint3(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+            TestUtils.AreEqual(a.z, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint3_static_constructor()
+        {
+            uint3 a = uint3(1, 2, 3);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+        }
+
+        [TestCompiler]
+        public static void uint3_static_scalar_constructor()
+        {
+            uint3 a = uint3(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+            TestUtils.AreEqual(a.z, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_equal_wide_wide()
+        {
+            uint3 a0 = uint3(790229414, 970783976, 1428432738);
+            uint3 b0 = uint3(612337669, 1214209108, 2120643427);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3 a1 = uint3(1578747135, 1733797753, 2001507228);
+            uint3 b1 = uint3(295461214, 1510890331, 1893316566);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3 a2 = uint3(1446876437, 1777406370, 1426387268);
+            uint3 b2 = uint3(921816149, 1834958575, 1482011863);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3 a3 = uint3(1809275021, 1843770816, 1172185222);
+            uint3 b3 = uint3(2062852792, 226398742, 770290735);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_equal_wide_scalar()
+        {
+            uint3 a0 = uint3(1211464300, 1921862607, 508076684);
+            uint b0 = (746972502);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3 a1 = uint3(1249127920, 746862310, 1733655277);
+            uint b1 = (1394594555);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3 a2 = uint3(1884008277, 795585660, 936027116);
+            uint b2 = (1682018538);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3 a3 = uint3(927605411, 1465584610, 585324157);
+            uint b3 = (672785749);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint3 b0 = uint3(233855098, 924242519, 1402948791);
+            bool3 r0 = bool3(false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (601381975);
+            uint3 b1 = uint3(2120518068, 629187703, 1971977031);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (47183124);
+            uint3 b2 = uint3(1061805787, 1009011238, 312511148);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1460673064);
+            uint3 b3 = uint3(737210539, 1737844479, 1892405453);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_not_equal_wide_wide()
+        {
+            uint3 a0 = uint3(1660932106, 982847023, 97046264);
+            uint3 b0 = uint3(107139049, 75478496, 2055495054);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3 a1 = uint3(1739517447, 1253499180, 1830584069);
+            uint3 b1 = uint3(358586687, 942338347, 111564990);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3 a2 = uint3(1841470429, 1397841646, 1770890135);
+            uint3 b2 = uint3(113811950, 948912488, 1080084121);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3 a3 = uint3(1906548631, 169082967, 2099271786);
+            uint3 b3 = uint3(1400504872, 1032134499, 1061123400);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_not_equal_wide_scalar()
+        {
+            uint3 a0 = uint3(747758183, 1033001286, 1439973882);
+            uint b0 = (248693828);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3 a1 = uint3(2138928797, 1432672459, 950170763);
+            uint b1 = (1197845089);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3 a2 = uint3(238704450, 727205263, 1640688041);
+            uint b2 = (2105962247);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3 a3 = uint3(276313906, 791998981, 2035077187);
+            uint b3 = (2126300423);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint3 b0 = uint3(2037494727, 1989050616, 48833929);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (1897435904);
+            uint3 b1 = uint3(514354517, 1783749164, 364694471);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (754315072);
+            uint3 b2 = uint3(124108032, 1512967900, 1178825850);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1854793298);
+            uint3 b3 = uint3(50286949, 2100802631, 1640811853);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_wide_wide()
+        {
+            uint3 a0 = uint3(1182186063, 415538999, 1667335818);
+            uint3 b0 = uint3(524633529, 1032195686, 760723389);
+            bool3 r0 = bool3(false, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3 a1 = uint3(1566618442, 1166180837, 639095188);
+            uint3 b1 = uint3(1505751409, 431962172, 1287906509);
+            bool3 r1 = bool3(false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3 a2 = uint3(1080836365, 771119973, 928263233);
+            uint3 b2 = uint3(1560084663, 1450178202, 2066166337);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3 a3 = uint3(789225474, 665243110, 1003542034);
+            uint3 b3 = uint3(1107069023, 1640077524, 2103263105);
+            bool3 r3 = bool3(true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_wide_scalar()
+        {
+            uint3 a0 = uint3(608447185, 818840405, 869219329);
+            uint b0 = (1491216667);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3 a1 = uint3(2080125385, 1361741203, 1667165786);
+            uint b1 = (1214500548);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3 a2 = uint3(1615392341, 469591900, 1247103789);
+            uint b2 = (840091491);
+            bool3 r2 = bool3(false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3 a3 = uint3(315321650, 1100560246, 933855388);
+            uint b3 = (930950514);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint3 b0 = uint3(282703327, 14370648, 1862117300);
+            bool3 r0 = bool3(false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1304793311);
+            uint3 b1 = uint3(826073259, 988910157, 445132446);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1139670255);
+            uint3 b2 = uint3(111349251, 1102440676, 112183144);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (1594415311);
+            uint3 b3 = uint3(1890019295, 2098715503, 608933527);
+            bool3 r3 = bool3(true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_wide_wide()
+        {
+            uint3 a0 = uint3(592884447, 2133928932, 918957182);
+            uint3 b0 = uint3(138737040, 192863971, 1700841444);
+            bool3 r0 = bool3(true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3 a1 = uint3(1284069471, 194584707, 739120780);
+            uint3 b1 = uint3(1044631301, 1391589821, 730837695);
+            bool3 r1 = bool3(true, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3 a2 = uint3(241654068, 1340158550, 2099542537);
+            uint3 b2 = uint3(253553987, 2078872742, 910845808);
+            bool3 r2 = bool3(false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3 a3 = uint3(1182623667, 1399607274, 789301637);
+            uint3 b3 = uint3(976047676, 202633078, 1223618940);
+            bool3 r3 = bool3(true, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_wide_scalar()
+        {
+            uint3 a0 = uint3(1097138316, 211763648, 1883002501);
+            uint b0 = (438688675);
+            bool3 r0 = bool3(true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3 a1 = uint3(56406996, 1923456111, 1437755186);
+            uint b1 = (43662641);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3 a2 = uint3(1219010035, 304028799, 893125636);
+            uint b2 = (2125058448);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3 a3 = uint3(48044515, 1035679270, 577943770);
+            uint b3 = (711945018);
+            bool3 r3 = bool3(false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint3 b0 = uint3(599356784, 185671342, 1932327391);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (2025591013);
+            uint3 b1 = uint3(1257191721, 1312388500, 1443698859);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (779217735);
+            uint3 b2 = uint3(691047512, 741776730, 732565983);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (668302204);
+            uint3 b3 = uint3(1556466996, 858599525, 1896917159);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_equal_wide_wide()
+        {
+            uint3 a0 = uint3(1577248162, 2043073061, 1688380407);
+            uint3 b0 = uint3(903445031, 2108974565, 210822256);
+            bool3 r0 = bool3(false, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3 a1 = uint3(176431985, 223299035, 1502802140);
+            uint3 b1 = uint3(1281704747, 453681718, 66138830);
+            bool3 r1 = bool3(true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3 a2 = uint3(1691709825, 386789394, 117182003);
+            uint3 b2 = uint3(1229799377, 1620922595, 1715833766);
+            bool3 r2 = bool3(false, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3 a3 = uint3(1665770435, 1958490731, 420032601);
+            uint3 b3 = uint3(1366430432, 13102000, 46919981);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_equal_wide_scalar()
+        {
+            uint3 a0 = uint3(1722165358, 1219858357, 860410743);
+            uint b0 = (1688048545);
+            bool3 r0 = bool3(false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3 a1 = uint3(411099660, 1963256951, 212084836);
+            uint b1 = (348104022);
+            bool3 r1 = bool3(false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3 a2 = uint3(58924407, 1745758438, 532949158);
+            uint b2 = (1459242706);
+            bool3 r2 = bool3(true, false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3 a3 = uint3(262559763, 1806172431, 2091514001);
+            uint b3 = (690091301);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint3 b0 = uint3(1181030049, 1787703989, 1729760948);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1816537388);
+            uint3 b1 = uint3(1359786460, 874999193, 1678863148);
+            bool3 r1 = bool3(false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (1711365839);
+            uint3 b2 = uint3(762067160, 11953554, 1131583906);
+            bool3 r2 = bool3(false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (1175393186);
+            uint3 b3 = uint3(1293698493, 48893340, 66196247);
+            bool3 r3 = bool3(true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_equal_wide_wide()
+        {
+            uint3 a0 = uint3(263000030, 744235661, 1893760267);
+            uint3 b0 = uint3(1395535146, 1178373944, 1237373760);
+            bool3 r0 = bool3(false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3 a1 = uint3(237248, 1062370984, 1676977687);
+            uint3 b1 = uint3(1364855321, 600811864, 362060472);
+            bool3 r1 = bool3(false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3 a2 = uint3(816766880, 1089431546, 1394493730);
+            uint3 b2 = uint3(290870624, 1839067862, 396958580);
+            bool3 r2 = bool3(true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3 a3 = uint3(1176473380, 1193988637, 1703862455);
+            uint3 b3 = uint3(1336888643, 1019684398, 1697684196);
+            bool3 r3 = bool3(false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_equal_wide_scalar()
+        {
+            uint3 a0 = uint3(2112791350, 1043657935, 101764761);
+            uint b0 = (1470533736);
+            bool3 r0 = bool3(true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3 a1 = uint3(1529909067, 281734132, 1186600258);
+            uint b1 = (556026890);
+            bool3 r1 = bool3(true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3 a2 = uint3(815093894, 1604309397, 829548642);
+            uint b2 = (609211196);
+            bool3 r2 = bool3(true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3 a3 = uint3(244604867, 471843809, 1819986195);
+            uint b3 = (1419295004);
+            bool3 r3 = bool3(false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint3 b0 = uint3(1503244746, 861711266, 817773856);
+            bool3 r0 = bool3(true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (925984572);
+            uint3 b1 = uint3(571221723, 683686810, 118252990);
+            bool3 r1 = bool3(true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (1653952090);
+            uint3 b2 = uint3(1240253990, 1947039008, 1869136019);
+            bool3 r2 = bool3(true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (152012637);
+            uint3 b3 = uint3(1214546726, 917376832, 303549425);
+            bool3 r3 = bool3(false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_add_wide_wide()
+        {
+            uint3 a0 = uint3(2049228671, 1658660009, 491719392);
+            uint3 b0 = uint3(2088751567, 645762023, 306868786);
+            uint3 r0 = uint3(4137980238, 2304422032, 798588178);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3 a1 = uint3(937013355, 81108663, 1063894558);
+            uint3 b1 = uint3(4360271, 506047997, 2094559874);
+            uint3 r1 = uint3(941373626, 587156660, 3158454432);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3 a2 = uint3(86954702, 843159721, 698977704);
+            uint3 b2 = uint3(1634712736, 1601474440, 1586485231);
+            uint3 r2 = uint3(1721667438, 2444634161, 2285462935);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3 a3 = uint3(192867135, 1683407172, 137301303);
+            uint3 b3 = uint3(908746788, 1812370320, 1247342357);
+            uint3 r3 = uint3(1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_add_wide_scalar()
+        {
+            uint3 a0 = uint3(2038218457, 134923711, 875689667);
+            uint b0 = (2124409227);
+            uint3 r0 = uint3(4162627684, 2259332938, 3000098894);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3 a1 = uint3(1338884463, 340490871, 1067888129);
+            uint b1 = (997710928);
+            uint3 r1 = uint3(2336595391, 1338201799, 2065599057);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3 a2 = uint3(70433301, 1635971971, 1160398286);
+            uint b2 = (2003021861);
+            uint3 r2 = uint3(2073455162, 3638993832, 3163420147);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3 a3 = uint3(85446202, 1239387100, 1497676888);
+            uint b3 = (1068152966);
+            uint3 r3 = uint3(1153599168, 2307540066, 2565829854);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint3 b0 = uint3(519908870, 851424292, 328314822);
+            uint3 r0 = uint3(911000948, 1242516370, 719406900);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (135622204);
+            uint3 b1 = uint3(740923360, 655394201, 1451896269);
+            uint3 r1 = uint3(876545564, 791016405, 1587518473);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1781697072);
+            uint3 b2 = uint3(996031825, 1557774949, 779774940);
+            uint3 r2 = uint3(2777728897, 3339472021, 2561472012);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1111541302);
+            uint3 b3 = uint3(783046445, 1130163944, 288279584);
+            uint3 r3 = uint3(1894587747, 2241705246, 1399820886);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_sub_wide_wide()
+        {
+            uint3 a0 = uint3(1353441118, 797269833, 659988112);
+            uint3 b0 = uint3(1332656812, 1827794007, 972557431);
+            uint3 r0 = uint3(20784306, 3264443122, 3982397977);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3 a1 = uint3(56022121, 365847472, 2062899435);
+            uint3 b1 = uint3(2078233689, 1508184327, 1372307701);
+            uint3 r1 = uint3(2272755728, 3152630441, 690591734);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3 a2 = uint3(1380988474, 799885138, 1306058185);
+            uint3 b2 = uint3(810327977, 936799885, 71562303);
+            uint3 r2 = uint3(570660497, 4158052549, 1234495882);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3 a3 = uint3(579775276, 1239163824, 344591081);
+            uint3 b3 = uint3(1418723328, 1971342989, 1226053395);
+            uint3 r3 = uint3(3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_sub_wide_scalar()
+        {
+            uint3 a0 = uint3(1176369558, 1934521195, 309452150);
+            uint b0 = (462232403);
+            uint3 r0 = uint3(714137155, 1472288792, 4142187043);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3 a1 = uint3(1417634074, 1306356714, 1502312334);
+            uint b1 = (108910717);
+            uint3 r1 = uint3(1308723357, 1197445997, 1393401617);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3 a2 = uint3(1451794815, 87530840, 1913724431);
+            uint b2 = (281174200);
+            uint3 r2 = uint3(1170620615, 4101323936, 1632550231);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3 a3 = uint3(2041593336, 1119051448, 1590376732);
+            uint b3 = (557239990);
+            uint3 r3 = uint3(1484353346, 561811458, 1033136742);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint3 b0 = uint3(2022393810, 1612688515, 496689713);
+            uint3 r0 = uint3(3964107891, 78845890, 1194844692);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (887037586);
+            uint3 b1 = uint3(2097630964, 374934538, 939035482);
+            uint3 r1 = uint3(3084373918, 512103048, 4242969400);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (935242277);
+            uint3 b2 = uint3(1789300421, 264712893, 1231856067);
+            uint3 r2 = uint3(3440909152, 670529384, 3998353506);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1818112748);
+            uint3 b3 = uint3(1428436109, 1258745460, 1077380396);
+            uint3 r3 = uint3(389676639, 559367288, 740732352);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mul_wide_wide()
+        {
+            uint3 a0 = uint3(245827027, 208934650, 1019478917);
+            uint3 b0 = uint3(759663997, 350129201, 477450108);
+            uint3 r0 = uint3(3662155527, 1402281434, 332447596);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3 a1 = uint3(568231809, 877289039, 1585782440);
+            uint3 b1 = uint3(1635735015, 388710278, 757722665);
+            uint3 r1 = uint3(2361989735, 2624048730, 1455036648);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3 a2 = uint3(2111178729, 1186019069, 571481445);
+            uint3 b2 = uint3(1509388321, 1841703980, 1826369331);
+            uint3 r2 = uint3(2128344329, 3700879228, 2640799263);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3 a3 = uint3(1570087048, 629447153, 619383734);
+            uint3 b3 = uint3(1524322467, 1605207974, 428419155);
+            uint3 r3 = uint3(2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mul_wide_scalar()
+        {
+            uint3 a0 = uint3(1762033447, 465343930, 1570757881);
+            uint b0 = (1476837906);
+            uint3 r0 = uint3(2981789374, 1326807828, 2156411778);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3 a1 = uint3(1326409563, 1356578909, 72749215);
+            uint b1 = (1824319147);
+            uint3 r1 = uint3(4042902473, 4058582047, 2167403573);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3 a2 = uint3(154616909, 573770299, 1958912969);
+            uint b2 = (975743632);
+            uint3 r2 = uint3(7966032, 414773040, 262642448);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3 a3 = uint3(971327747, 1324050764, 660611671);
+            uint b3 = (1818877398);
+            uint3 r3 = uint3(2347605890, 1927061896, 2981154746);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint3 b0 = uint3(1764461774, 657072478, 1459784358);
+            uint3 r0 = uint3(3344568648, 4192918280, 1260585960);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1610646683);
+            uint3 b1 = uint3(1632058826, 868441654, 1408757883);
+            uint3 r1 = uint3(1644073294, 1407050418, 3474851449);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (335917146);
+            uint3 b2 = uint3(2105124483, 1178393968, 1963904348);
+            uint3 r2 = uint3(1003330062, 2631063904, 2268033624);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (1409533767);
+            uint3 b3 = uint3(243286231, 1336308795, 517963367);
+            uint3 r3 = uint3(108928161, 875895133, 2457018257);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_div_wide_wide()
+        {
+            uint3 a0 = uint3(1590198532, 507812502, 126627032);
+            uint3 b0 = uint3(1434703236, 911965201, 390415521);
+            uint3 r0 = uint3(1, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3 a1 = uint3(1058247011, 427387861, 290676154);
+            uint3 b1 = uint3(128746927, 525835375, 816946613);
+            uint3 r1 = uint3(8, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3 a2 = uint3(1829594484, 1127868739, 499016351);
+            uint3 b2 = uint3(878264647, 146789678, 2089524057);
+            uint3 r2 = uint3(2, 7, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3 a3 = uint3(1341209632, 134906097, 785470242);
+            uint3 b3 = uint3(254213018, 1916850021, 1737806518);
+            uint3 r3 = uint3(5, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_div_wide_scalar()
+        {
+            uint3 a0 = uint3(560951562, 1218680769, 375341724);
+            uint b0 = (947861580);
+            uint3 r0 = uint3(0, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3 a1 = uint3(1613542090, 1397425408, 1349573078);
+            uint b1 = (1919409166);
+            uint3 r1 = uint3(0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3 a2 = uint3(524526253, 495895326, 1515313790);
+            uint b2 = (341995568);
+            uint3 r2 = uint3(1, 1, 4);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3 a3 = uint3(1676971657, 2105094094, 1017891310);
+            uint b3 = (2131487088);
+            uint3 r3 = uint3(0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint3 b0 = uint3(187325733, 1594107378, 2016183849);
+            uint3 r0 = uint3(6, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (1589343709);
+            uint3 b1 = uint3(388768753, 1417077283, 1773486938);
+            uint3 r1 = uint3(4, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1154044032);
+            uint3 b2 = uint3(81831373, 1476877645, 653688843);
+            uint3 r2 = uint3(14, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (45756703);
+            uint3 b3 = uint3(631027637, 396671391, 784365696);
+            uint3 r3 = uint3(0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mod_wide_wide()
+        {
+            uint3 a0 = uint3(146150818, 1846543305, 1071447756);
+            uint3 b0 = uint3(983050390, 771341152, 942375212);
+            uint3 r0 = uint3(146150818, 303861001, 129072544);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3 a1 = uint3(308965362, 659881575, 1002365460);
+            uint3 b1 = uint3(367361754, 749500619, 750718852);
+            uint3 r1 = uint3(308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3 a2 = uint3(861198439, 1510617532, 778525078);
+            uint3 b2 = uint3(2095151755, 88438806, 769227442);
+            uint3 r2 = uint3(861198439, 7157830, 9297636);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3 a3 = uint3(1458458044, 101987897, 1249565173);
+            uint3 b3 = uint3(647214624, 1026513788, 1544950956);
+            uint3 r3 = uint3(164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mod_wide_scalar()
+        {
+            uint3 a0 = uint3(164800505, 1062177828, 1898749675);
+            uint b0 = (883951171);
+            uint3 r0 = uint3(164800505, 178226657, 130847333);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3 a1 = uint3(1701653318, 19002208, 128329633);
+            uint b1 = (820393245);
+            uint3 r1 = uint3(60866828, 19002208, 128329633);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3 a2 = uint3(1464010899, 405208598, 1982762194);
+            uint b2 = (896587769);
+            uint3 r2 = uint3(567423130, 405208598, 189586656);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3 a3 = uint3(959236935, 172564850, 1540068445);
+            uint b3 = (712321026);
+            uint3 r3 = uint3(246915909, 172564850, 115426393);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint3 b0 = uint3(740000543, 1556450291, 1104736385);
+            uint3 r0 = uint3(242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (437976569);
+            uint3 b1 = uint3(1911837205, 1507212038, 1906405167);
+            uint3 r1 = uint3(437976569, 437976569, 437976569);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (247693265);
+            uint3 b2 = uint3(293460573, 1495295166, 873323603);
+            uint3 r2 = uint3(247693265, 247693265, 247693265);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (530681233);
+            uint3 b3 = uint3(1298102643, 2057984657, 1000742091);
+            uint3 r3 = uint3(530681233, 530681233, 530681233);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_plus()
+        {
+            uint3 a0 = uint3(1643476803, 907898539, 379615839);
+            uint3 r0 = uint3(1643476803, 907898539, 379615839);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint3 a1 = uint3(1140483021, 1743199272, 1472881565);
+            uint3 r1 = uint3(1140483021, 1743199272, 1472881565);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint3 a2 = uint3(339091479, 1287765427, 849339193);
+            uint3 r2 = uint3(339091479, 1287765427, 849339193);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint3 a3 = uint3(174532915, 1566098441, 1145639744);
+            uint3 r3 = uint3(174532915, 1566098441, 1145639744);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_neg()
+        {
+            uint3 a0 = uint3(1955022112, 662160019, 370300775);
+            uint3 r0 = uint3(2339945184, 3632807277, 3924666521);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint3 a1 = uint3(2141283773, 28153593, 33894270);
+            uint3 r1 = uint3(2153683523, 4266813703, 4261073026);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint3 a2 = uint3(505708349, 1636274969, 694995093);
+            uint3 r2 = uint3(3789258947, 2658692327, 3599972203);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint3 a3 = uint3(1542206286, 243937487, 341522275);
+            uint3 r3 = uint3(2752761010, 4051029809, 3953445021);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_prefix_inc()
+        {
+            uint3 a0 = uint3(864455342, 2035793213, 1275443862);
+            uint3 r0 = uint3(864455343, 2035793214, 1275443863);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint3 a1 = uint3(971919915, 446210725, 395072276);
+            uint3 r1 = uint3(971919916, 446210726, 395072277);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint3 a2 = uint3(115573442, 432884105, 1208161871);
+            uint3 r2 = uint3(115573443, 432884106, 1208161872);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint3 a3 = uint3(1385544935, 831396561, 388229350);
+            uint3 r3 = uint3(1385544936, 831396562, 388229351);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_postfix_inc()
+        {
+            uint3 a0 = uint3(1751003569, 2063707595, 1500486291);
+            uint3 r0 = uint3(1751003569, 2063707595, 1500486291);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint3 a1 = uint3(969189211, 2028651936, 1643023524);
+            uint3 r1 = uint3(969189211, 2028651936, 1643023524);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint3 a2 = uint3(1190630527, 708474528, 177416855);
+            uint3 r2 = uint3(1190630527, 708474528, 177416855);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint3 a3 = uint3(1524860667, 375284401, 1580130369);
+            uint3 r3 = uint3(1524860667, 375284401, 1580130369);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_prefix_dec()
+        {
+            uint3 a0 = uint3(200904609, 871077500, 968578728);
+            uint3 r0 = uint3(200904608, 871077499, 968578727);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint3 a1 = uint3(638967721, 435367037, 1782514098);
+            uint3 r1 = uint3(638967720, 435367036, 1782514097);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint3 a2 = uint3(1589827826, 596759698, 1699290403);
+            uint3 r2 = uint3(1589827825, 596759697, 1699290402);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint3 a3 = uint3(1758478358, 71237375, 389120307);
+            uint3 r3 = uint3(1758478357, 71237374, 389120306);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_postfix_dec()
+        {
+            uint3 a0 = uint3(283970262, 1109329936, 1073216143);
+            uint3 r0 = uint3(283970262, 1109329936, 1073216143);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint3 a1 = uint3(649439137, 1174104498, 484207852);
+            uint3 r1 = uint3(649439137, 1174104498, 484207852);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint3 a2 = uint3(524156737, 2017728859, 802721301);
+            uint3 r2 = uint3(524156737, 2017728859, 802721301);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint3 a3 = uint3(377162390, 1504625034, 590919177);
+            uint3 r3 = uint3(377162390, 1504625034, 590919177);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_and_wide_wide()
+        {
+            uint3 a0 = uint3(779935043, 1097962163, 1939593304);
+            uint3 b0 = uint3(307705143, 1710882162, 866836769);
+            uint3 r0 = uint3(39064835, 1097961522, 864731136);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3 a1 = uint3(800599247, 952140918, 782792558);
+            uint3 b1 = uint3(532490608, 679371720, 1794035877);
+            uint3 r1 = uint3(263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3 a2 = uint3(1608557706, 396446406, 2039894114);
+            uint3 b2 = uint3(1439832202, 519529812, 23633139);
+            uint3 r2 = uint3(1438646410, 379666500, 16781410);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3 a3 = uint3(1286974642, 442394124, 1759739564);
+            uint3 b3 = uint3(1209152681, 646737179, 1255867027);
+            uint3 r3 = uint3(1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_and_wide_scalar()
+        {
+            uint3 a0 = uint3(443615469, 490057985, 2042441263);
+            uint b0 = (93423598);
+            uint3 r0 = uint3(1114348, 85033216, 26281518);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3 a1 = uint3(1524760558, 510212004, 1941875181);
+            uint b1 = (1405175110);
+            uint3 r1 = uint3(1388397894, 306251012, 1400897860);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3 a2 = uint3(1236735839, 428270198, 607982857);
+            uint b2 = (1365509729);
+            uint3 r2 = uint3(1092879937, 285475424, 2360321);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3 a3 = uint3(650270920, 814629680, 1862276471);
+            uint b3 = (1249238550);
+            uint3 r3 = uint3(37771264, 279056, 1241519126);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint3 b0 = uint3(420346723, 562416448, 1393127318);
+            uint3 r0 = uint3(547170, 18752, 1074284806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1560699552);
+            uint3 b1 = uint3(851218057, 703880958, 1159378889);
+            uint3 r1 = uint3(268698240, 151274144, 1157767808);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (2031211279);
+            uint3 b2 = uint3(1089518981, 270607307, 1349288930);
+            uint3 r2 = uint3(1074827525, 268501771, 1342210818);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (520199596);
+            uint3 b3 = uint3(1763483957, 1248975349, 236938635);
+            uint3 r3 = uint3(151028004, 167877028, 234947976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_or_wide_wide()
+        {
+            uint3 a0 = uint3(1731159103, 659068416, 382702471);
+            uint3 b0 = uint3(1583847161, 692672727, 1161585489);
+            uint3 r0 = uint3(2138044159, 793370327, 1476391895);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3 a1 = uint3(1821032196, 1565773438, 1004000514);
+            uint3 b1 = uint3(1756207130, 1321374429, 1287357212);
+            uint3 r1 = uint3(1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3 a2 = uint3(948501377, 600951835, 669346222);
+            uint3 b2 = uint3(2075767170, 1273513430, 1610830169);
+            uint3 r2 = uint3(2075786115, 1811533279, 1743223295);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3 a3 = uint3(396691477, 2108560248, 2117522137);
+            uint3 b3 = uint3(1316929125, 511625048, 573925879);
+            uint3 r3 = uint3(1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_or_wide_scalar()
+        {
+            uint3 a0 = uint3(961259683, 471103264, 1733389229);
+            uint b0 = (1666102508);
+            uint3 r0 = uint3(2068823279, 2136930284, 1734344685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3 a1 = uint3(1591585258, 1148351449, 1048929715);
+            uint b1 = (386953869);
+            uint3 r1 = uint3(1608383471, 1467118557, 1066760127);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3 a2 = uint3(1814263250, 1637162093, 1227888278);
+            uint b2 = (860336789);
+            uint3 r2 = uint3(2137520087, 1943518973, 2071443095);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3 a3 = uint3(774029856, 1179087439, 797240690);
+            uint b3 = (879300408);
+            uint3 r3 = uint3(1047252792, 1987018623, 1072557946);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint3 b0 = uint3(1212928242, 1614462616, 936937728);
+            uint3 r0 = uint3(1213978111, 1752940445, 2145094925);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (764766995);
+            uint3 b1 = uint3(306352095, 574719481, 1283571271);
+            uint3 r1 = uint3(1071116255, 802549755, 1838546775);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (2109131012);
+            uint3 b2 = uint3(979469710, 1348323481, 1407542578);
+            uint3 r2 = uint3(2146946446, 2113915293, 2146954550);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (697517649);
+            uint3 b3 = uint3(1059093741, 627815046, 418822515);
+            uint3 r3 = uint3(1068728061, 771487447, 972554099);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_xor_wide_wide()
+        {
+            uint3 a0 = uint3(1556324760, 207002929, 1843444873);
+            uint3 b0 = uint3(1054997548, 1523759632, 251164872);
+            uint3 r0 = uint3(1646419380, 1451501345, 1662567489);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3 a1 = uint3(1632079131, 1460334334, 1607815585);
+            uint3 b1 = uint3(110472397, 384031112, 1109163205);
+            uint3 r1 = uint3(1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3 a2 = uint3(220623650, 38668553, 47193340);
+            uint3 b2 = uint3(535118981, 179106262, 1523031711);
+            uint3 r2 = uint3(314783655, 149092575, 1477935715);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3 a3 = uint3(643663548, 1371932564, 94957188);
+            uint3 b3 = uint3(1713313372, 1294118730, 520360641);
+            uint3 r3 = uint3(1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_xor_wide_scalar()
+        {
+            uint3 a0 = uint3(2124666952, 177397845, 574879617);
+            uint b0 = (493665894);
+            uint3 r0 = uint3(1674536494, 402546227, 1060063719);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3 a1 = uint3(1937385541, 213863690, 535061373);
+            uint b1 = (1136545648);
+            uint3 r1 = uint3(818177845, 1325466234, 1549413389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3 a2 = uint3(289301586, 353786540, 1308626970);
+            uint b2 = (1305234431);
+            uint3 r2 = uint3(1559375789, 1490686291, 63724517);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3 a3 = uint3(1267729267, 1315625690, 1730088797);
+            uint b3 = (125659640);
+            uint3 r3 = uint3(1290627723, 1226289954, 1617061541);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint3 b0 = uint3(1077599928, 884741329, 212164516);
+            uint3 r0 = uint3(217506340, 2020616269, 1080648504);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1585020328);
+            uint3 b1 = uint3(152985454, 1775851275, 1416249064);
+            uint3 r1 = uint3(1466376902, 933243555, 169034560);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1309317737);
+            uint3 b2 = uint3(1773918217, 1509843030, 1206045972);
+            uint3 r2 = uint3(665928288, 401930815, 166221693);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1154916424);
+            uint3 b3 = uint3(1947871003, 1774252400, 1946113778);
+            uint3 r3 = uint3(818710355, 756437304, 925497018);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_left_shift()
+        {
+            uint3 a0 = uint3(197771193, 622182602, 1283988958);
+            int b0 = (1321149625);
+            uint3 r0 = uint3(1912602624, 2483027968, 3154116608);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint3 a1 = uint3(1327917304, 432425717, 870301196);
+            int b1 = (473415985);
+            uint3 r1 = uint3(3522166784, 2515140608, 2081947648);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint3 a2 = uint3(2058433484, 1531607705, 1360008038);
+            int b2 = (1200694230);
+            uint3 r2 = uint3(4076863488, 2789212160, 3649044480);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint3 a3 = uint3(1008296534, 1079614371, 35667343);
+            int b3 = (1447702302);
+            uint3 r3 = uint3(2147483648, 3221225472, 3221225472);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_right_shift()
+        {
+            uint3 a0 = uint3(548167301, 1161338299, 1617625829);
+            int b0 = (1266801540);
+            uint3 r0 = uint3(34260456, 72583643, 101101614);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint3 a1 = uint3(1860731847, 196552656, 770466193);
+            int b1 = (713958715);
+            uint3 r1 = uint3(13, 1, 5);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint3 a2 = uint3(1265099998, 506619530, 426807581);
+            int b2 = (572763124);
+            uint3 r2 = uint3(1206, 483, 407);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint3 a3 = uint3(2031319045, 917785020, 569504877);
+            int b3 = (701927980);
+            uint3 r3 = uint3(495927, 224068, 139039);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_operator_bitwise_not()
+        {
+            uint3 a0 = uint3(1403358969, 831360921, 2088190243);
+            uint3 r0 = uint3(2891608326, 3463606374, 2206777052);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint3 a1 = uint3(976721016, 308994339, 1935567517);
+            uint3 r1 = uint3(3318246279, 3985972956, 2359399778);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint3 a2 = uint3(1420884856, 771711426, 627580960);
+            uint3 r2 = uint3(2874082439, 3523255869, 3667386335);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint3 a3 = uint3(2061524024, 2097179283, 1303022493);
+            uint3 r3 = uint3(2233443271, 2197788012, 2991944802);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3_shuffle_result_1()
+        {
+            uint3 a = uint3(0, 1, 2);
+            uint3 b = uint3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ), (5));
+        }
+
+        [TestCompiler]
+        public static void uint3_shuffle_result_2()
+        {
+            uint3 a = uint3(0, 1, 2);
+            uint3 b = uint3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), uint2(4, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), uint2(4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint2(1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), uint2(5, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY), uint2(5, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), uint2(1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftZ), uint2(3, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), uint2(5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), uint2(5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), uint2(4, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), uint2(4, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), uint2(5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), uint2(4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY), uint2(5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), uint2(3, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), uint2(1, 2));
+        }
+
+        [TestCompiler]
+        public static void uint3_shuffle_result_3()
+        {
+            uint3 a = uint3(0, 1, 2);
+            uint3 b = uint3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.RightX), uint3(1, 5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), uint3(4, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX), uint3(2, 5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY), uint3(4, 0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.LeftZ), uint3(5, 4, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.LeftY), uint3(2, 0, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightX), uint3(2, 4, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftY, ShuffleComponent.RightZ), uint3(2, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ), uint3(4, 4, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), uint3(4, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), uint3(5, 5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint3(5, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightZ), uint3(4, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightY), uint3(2, 3, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint3(4, 0, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ), uint3(4, 0, 5));
+        }
+
+        [TestCompiler]
+        public static void uint3_shuffle_result_4()
+        {
+            uint3 a = uint3(0, 1, 2);
+            uint3 b = uint3(3, 4, 5);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY), uint4(1, 2, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightY), uint4(4, 2, 5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.LeftY), uint4(4, 4, 5, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint4(3, 3, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), uint4(4, 1, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightZ), uint4(3, 4, 3, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightZ), uint4(1, 5, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), uint4(4, 0, 0, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightZ, ShuffleComponent.LeftZ, ShuffleComponent.LeftX), uint4(3, 5, 2, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint4(4, 3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), uint4(0, 2, 5, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.RightZ), uint4(1, 4, 5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint4(2, 3, 1, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), uint4(3, 0, 1, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(5, 3, 0, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(2, 5, 0, 4));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..1fb2cc2601f4d3f6759728e12d6c242643b9eccc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e540f901d21a5c4c94afaaa341f0eba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..6eab9de08c876eae34ca68cf1e0295c244fab06c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs
@@ -0,0 +1,1227 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint3x2
+    {
+        [TestCompiler]
+        public static void uint3x2_zero()
+        {
+            TestUtils.AreEqual(uint3x2.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint3x2.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint3x2.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint3x2.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint3x2.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint3x2.zero.c1.z, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_equal_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228);
+            uint3x2 b0 = uint3x2(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x2 a1 = uint3x2(1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            uint3x2 b1 = uint3x2(921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x2 a2 = uint3x2(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            uint3x2 b2 = uint3x2(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x2 a3 = uint3x2(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint3x2 b3 = uint3x2(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_equal_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310);
+            uint b0 = (746972502);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x2 a1 = uint3x2(1733655277, 1682018538, 795585660, 936027116, 927605411, 672785749);
+            uint b1 = (1884008277);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x2 a2 = uint3x2(1465584610, 404448210, 969511077, 442746747, 1772925698, 1884034177);
+            uint b2 = (585324157);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x2 a3 = uint3x2(451512860, 1370577708, 597010220, 1249636005, 211986678, 1305479811);
+            uint b3 = (425476075);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint3x2 b0 = uint3x2(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703);
+            bool3x2 r0 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1971977031);
+            uint3x2 b1 = uint3x2(47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (1737844479);
+            uint3x2 b2 = uint3x2(1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (559824292);
+            uint3x2 b3 = uint3x2(1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_not_equal_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069);
+            uint3x2 b0 = uint3x2(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x2 a1 = uint3x2(1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            uint3x2 b1 = uint3x2(113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x2 a2 = uint3x2(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            uint3x2 b2 = uint3x2(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x2 a3 = uint3x2(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint3x2 b3 = uint3x2(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_not_equal_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459);
+            uint b0 = (248693828);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x2 a1 = uint3x2(950170763, 2105962247, 727205263, 1640688041, 276313906, 2126300423);
+            uint b1 = (238704450);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x2 a2 = uint3x2(791998981, 1171827730, 1412347883, 1622176923, 768370497, 1072798259);
+            uint b2 = (2035077187);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x2 a3 = uint3x2(1808712713, 1582645163, 1876273820, 90244766, 30493685, 904014575);
+            uint b3 = (1497830076);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint3x2 b0 = uint3x2(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (364694471);
+            uint3x2 b1 = uint3x2(754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (2100802631);
+            uint3x2 b2 = uint3x2(1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1041416160);
+            uint3x2 b3 = uint3x2(356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024);
+            bool3x2 r3 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188);
+            uint3x2 b0 = uint3x2(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509);
+            bool3x2 r0 = bool3x2(false, true, false, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x2 a1 = uint3x2(1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            uint3x2 b1 = uint3x2(1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x2 a2 = uint3x2(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            uint3x2 b2 = uint3x2(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x2 a3 = uint3x2(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint3x2 b3 = uint3x2(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool3x2 r3 = bool3x2(true, true, false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203);
+            uint b0 = (1491216667);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x2 a1 = uint3x2(1667165786, 840091491, 469591900, 1247103789, 315321650, 930950514);
+            uint b1 = (1615392341);
+            bool3x2 r1 = bool3x2(false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x2 a2 = uint3x2(1100560246, 908563901, 1127696709, 1286331950, 380753337, 971148054);
+            uint b2 = (933855388);
+            bool3x2 r2 = bool3x2(false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x2 a3 = uint3x2(1827886929, 1579735991, 689044913, 1960894027, 371987110, 867559111);
+            uint b3 = (1056649851);
+            bool3x2 r3 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint3x2 b0 = uint3x2(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157);
+            bool3x2 r0 = bool3x2(false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (445132446);
+            uint3x2 b1 = uint3x2(1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (2098715503);
+            uint3x2 b2 = uint3x2(608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (874278078);
+            uint3x2 b3 = uint3x2(1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911);
+            bool3x2 r3 = bool3x2(true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780);
+            uint3x2 b0 = uint3x2(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695);
+            bool3x2 r0 = bool3x2(true, true, false, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x2 a1 = uint3x2(241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            uint3x2 b1 = uint3x2(253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool3x2 r1 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x2 a2 = uint3x2(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            uint3x2 b2 = uint3x2(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool3x2 r2 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x2 a3 = uint3x2(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint3x2 b3 = uint3x2(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool3x2 r3 = bool3x2(false, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111);
+            uint b0 = (438688675);
+            bool3x2 r0 = bool3x2(true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x2 a1 = uint3x2(1437755186, 2125058448, 304028799, 893125636, 48044515, 711945018);
+            uint b1 = (1219010035);
+            bool3x2 r1 = bool3x2(true, true, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x2 a2 = uint3x2(1035679270, 572743717, 1016617211, 2063134811, 1577403353, 64009107);
+            uint b2 = (577943770);
+            bool3x2 r2 = bool3x2(true, false, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x2 a3 = uint3x2(1462961460, 3715845, 689362811, 263973424, 1045140419, 1058332184);
+            uint b3 = (1143565920);
+            bool3x2 r3 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint3x2 b0 = uint3x2(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500);
+            bool3x2 r0 = bool3x2(true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1443698859);
+            uint3x2 b1 = uint3x2(779217735, 691047512, 741776730, 732565983, 668302204, 1556466996);
+            bool3x2 r1 = bool3x2(true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (858599525);
+            uint3x2 b2 = uint3x2(1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345);
+            bool3x2 r2 = bool3x2(false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (299897686);
+            uint3x2 b3 = uint3x2(632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296);
+            bool3x2 r3 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_equal_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140);
+            uint3x2 b0 = uint3x2(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830);
+            bool3x2 r0 = bool3x2(false, true, false, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x2 a1 = uint3x2(1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            uint3x2 b1 = uint3x2(1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool3x2 r1 = bool3x2(false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x2 a2 = uint3x2(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            uint3x2 b2 = uint3x2(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool3x2 r2 = bool3x2(false, false, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x2 a3 = uint3x2(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint3x2 b3 = uint3x2(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool3x2 r3 = bool3x2(true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_equal_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951);
+            uint b0 = (1688048545);
+            bool3x2 r0 = bool3x2(false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x2 a1 = uint3x2(212084836, 1459242706, 1745758438, 532949158, 262559763, 690091301);
+            uint b1 = (58924407);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x2 a2 = uint3x2(1806172431, 1857173043, 1617221948, 2017733017, 804204255, 981729559);
+            uint b2 = (2091514001);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x2 a3 = uint3x2(2032949254, 2079225209, 26179915, 238796519, 1917813750, 1258115260);
+            uint b3 = (910922522);
+            bool3x2 r3 = bool3x2(false, false, true, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint3x2 b0 = uint3x2(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1678863148);
+            uint3x2 b1 = uint3x2(1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493);
+            bool3x2 r1 = bool3x2(true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (48893340);
+            uint3x2 b2 = uint3x2(66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737);
+            bool3x2 r2 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (117849810);
+            uint3x2 b3 = uint3x2(1348693584, 105489302, 259034238, 530713566, 601413850, 830430286);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_equal_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687);
+            uint3x2 b0 = uint3x2(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472);
+            bool3x2 r0 = bool3x2(false, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x2 a1 = uint3x2(816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            uint3x2 b1 = uint3x2(290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool3x2 r1 = bool3x2(true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x2 a2 = uint3x2(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            uint3x2 b2 = uint3x2(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool3x2 r2 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x2 a3 = uint3x2(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint3x2 b3 = uint3x2(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool3x2 r3 = bool3x2(false, true, false, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_equal_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132);
+            uint b0 = (1470533736);
+            bool3x2 r0 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x2 a1 = uint3x2(1186600258, 609211196, 1604309397, 829548642, 244604867, 1419295004);
+            uint b1 = (815093894);
+            bool3x2 r1 = bool3x2(true, false, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x2 a2 = uint3x2(471843809, 1460027917, 1646290021, 196833647, 1596738181, 1905036391);
+            uint b2 = (1819986195);
+            bool3x2 r2 = bool3x2(false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x2 a3 = uint3x2(1771391775, 370941146, 440219668, 1607345862, 1449142607, 1223010129);
+            uint b3 = (1584946560);
+            bool3x2 r3 = bool3x2(true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint3x2 b0 = uint3x2(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810);
+            bool3x2 r0 = bool3x2(true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (118252990);
+            uint3x2 b1 = uint3x2(1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726);
+            bool3x2 r1 = bool3x2(false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (917376832);
+            uint3x2 b2 = uint3x2(303549425, 2111728811, 945321577, 173706579, 625318949, 519443238);
+            bool3x2 r2 = bool3x2(true, false, false, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (1583588379);
+            uint3x2 b3 = uint3x2(1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308);
+            bool3x2 r3 = bool3x2(true, false, true, true, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_add_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558);
+            uint3x2 b0 = uint3x2(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874);
+            uint3x2 r0 = uint3x2(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x2 a1 = uint3x2(86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            uint3x2 b1 = uint3x2(1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            uint3x2 r1 = uint3x2(1721667438, 2444634161, 2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x2 a2 = uint3x2(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            uint3x2 b2 = uint3x2(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            uint3x2 r2 = uint3x2(4147356693, 749502583, 623052937, 3113339623, 2178242226, 3146426160);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x2 a3 = uint3x2(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint3x2 b3 = uint3x2(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint3x2 r3 = uint3x2(1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_add_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871);
+            uint b0 = (2124409227);
+            uint3x2 r0 = uint3x2(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x2 a1 = uint3x2(1067888129, 2003021861, 1635971971, 1160398286, 85446202, 1068152966);
+            uint b1 = (70433301);
+            uint3x2 r1 = uint3x2(1138321430, 2073455162, 1706405272, 1230831587, 155879503, 1138586267);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x2 a2 = uint3x2(1239387100, 1727477485, 1095438654, 756559204, 1818718931, 658923552);
+            uint b2 = (1497676888);
+            uint3x2 r2 = uint3x2(2737063988, 3225154373, 2593115542, 2254236092, 3316395819, 2156600440);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x2 a3 = uint3x2(1610518921, 692843300, 1068593469, 1704776233, 577782260, 736972565);
+            uint b3 = (1585755398);
+            uint3x2 r3 = uint3x2(3196274319, 2278598698, 2654348867, 3290531631, 2163537658, 2322727963);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint3x2 b0 = uint3x2(519908870, 851424292, 328314822, 135622204, 740923360, 655394201);
+            uint3x2 r0 = uint3x2(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (1451896269);
+            uint3x2 b1 = uint3x2(1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445);
+            uint3x2 r1 = uint3x2(3233593341, 2447928094, 3009671218, 2231671209, 2563437571, 2234942714);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1130163944);
+            uint3x2 b2 = uint3x2(288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965);
+            uint3x2 r2 = uint3x2(1418443528, 2527847805, 2766747433, 1803427283, 2599464818, 1145019909);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1116636999);
+            uint3x2 b3 = uint3x2(1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835);
+            uint3x2 r3 = uint3x2(2605500299, 2717627885, 1307288300, 2424096767, 2036722838, 3198866834);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_sub_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435);
+            uint3x2 b0 = uint3x2(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701);
+            uint3x2 r0 = uint3x2(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x2 a1 = uint3x2(1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            uint3x2 b1 = uint3x2(810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            uint3x2 r1 = uint3x2(570660497, 4158052549, 1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x2 a2 = uint3x2(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            uint3x2 b2 = uint3x2(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            uint3x2 r2 = uint3x2(4244761393, 3364773944, 120810088, 929308315, 3670565287, 4129068219);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x2 a3 = uint3x2(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint3x2 b3 = uint3x2(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint3x2 r3 = uint3x2(3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_sub_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714);
+            uint b0 = (462232403);
+            uint3x2 r0 = uint3x2(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x2 a1 = uint3x2(1502312334, 281174200, 87530840, 1913724431, 2041593336, 557239990);
+            uint b1 = (1451794815);
+            uint3x2 r1 = uint3x2(50517519, 3124346681, 2930703321, 461929616, 589798521, 3400412471);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x2 a2 = uint3x2(1119051448, 819090189, 816382635, 815920639, 1829033117, 1792801932);
+            uint b2 = (1590376732);
+            uint3x2 r2 = uint3x2(3823642012, 3523680753, 3520973199, 3520511203, 238656385, 202425200);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x2 a3 = uint3x2(1113440549, 1277257189, 2092779398, 642236742, 1605250794, 819644478);
+            uint b3 = (1418937976);
+            uint3x2 r3 = uint3x2(3989469869, 4153286509, 673841422, 3518266062, 186312818, 3695673798);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint3x2 b0 = uint3x2(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538);
+            uint3x2 r0 = uint3x2(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (939035482);
+            uint3x2 b1 = uint3x2(935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109);
+            uint3x2 r1 = uint3x2(3793205, 3444702357, 674322589, 4002146711, 3415890030, 3805566669);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (1258745460);
+            uint3x2 b2 = uint3x2(1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918);
+            uint3x2 r2 = uint3x2(181365064, 4222990037, 740633631, 291616931, 914079206, 176477542);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (907866696);
+            uint3x2 b3 = uint3x2(1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777);
+            uint3x2 r3 = uint3x2(3385948869, 447526128, 4240679494, 350753235, 3501617283, 3222735215);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mul_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440);
+            uint3x2 b0 = uint3x2(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665);
+            uint3x2 r0 = uint3x2(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x2 a1 = uint3x2(2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            uint3x2 b1 = uint3x2(1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            uint3x2 r1 = uint3x2(2128344329, 3700879228, 2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x2 a2 = uint3x2(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            uint3x2 b2 = uint3x2(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            uint3x2 r2 = uint3x2(990589280, 3356793344, 2953243830, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x2 a3 = uint3x2(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint3x2 b3 = uint3x2(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint3x2 r3 = uint3x2(1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mul_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909);
+            uint b0 = (1476837906);
+            uint3x2 r0 = uint3x2(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x2 a1 = uint3x2(72749215, 975743632, 573770299, 1958912969, 971327747, 1818877398);
+            uint b1 = (154616909);
+            uint3x2 r1 = uint3x2(1400257491, 7966032, 499040191, 322676597, 469811687, 3921580382);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x2 a2 = uint3x2(1324050764, 1279757657, 391009467, 1186856590, 890343818, 800117742);
+            uint b2 = (660611671);
+            uint3x2 r2 = uint3x2(645718228, 4252425023, 2516558221, 1570790978, 4161587686, 1820172770);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x2 a3 = uint3x2(606927173, 1688964615, 1439447294, 387721300, 1192501703, 1613845584);
+            uint b3 = (1338014500);
+            uint3x2 r3 = uint3x2(4040635572, 1134384636, 1352273336, 4065724368, 1766808828, 645024576);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint3x2 b0 = uint3x2(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654);
+            uint3x2 r0 = uint3x2(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1408757883);
+            uint3x2 b1 = uint3x2(335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231);
+            uint3x2 r1 = uint3x2(1223039806, 1995624689, 3320276176, 375843636, 858017565, 2027534157);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1336308795);
+            uint3x2 b2 = uint3x2(517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700);
+            uint3x2 r2 = uint3x2(580046269, 3297097280, 3969951899, 831291671, 3260394293, 3040627372);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (677771573);
+            uint3x2 b3 = uint3x2(2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236);
+            uint3x2 r3 = uint3x2(4169123457, 1435043573, 698030233, 9173379, 3470328490, 113055164);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_div_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154);
+            uint3x2 b0 = uint3x2(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613);
+            uint3x2 r0 = uint3x2(1, 0, 0, 8, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x2 a1 = uint3x2(1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            uint3x2 b1 = uint3x2(878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            uint3x2 r1 = uint3x2(2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x2 a2 = uint3x2(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            uint3x2 b2 = uint3x2(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            uint3x2 r2 = uint3x2(0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x2 a3 = uint3x2(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint3x2 b3 = uint3x2(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint3x2 r3 = uint3x2(0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_div_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408);
+            uint b0 = (947861580);
+            uint3x2 r0 = uint3x2(0, 1, 0, 1, 2, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x2 a1 = uint3x2(1349573078, 341995568, 495895326, 1515313790, 1676971657, 2131487088);
+            uint b1 = (524526253);
+            uint3x2 r1 = uint3x2(2, 0, 0, 2, 3, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x2 a2 = uint3x2(2105094094, 542666029, 1646044372, 1447236569, 107215658, 19616726);
+            uint b2 = (1017891310);
+            uint3x2 r2 = uint3x2(2, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x2 a3 = uint3x2(896899915, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864);
+            uint b3 = (707389627);
+            uint3x2 r3 = uint3x2(1, 1, 2, 2, 2, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint3x2 b0 = uint3x2(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283);
+            uint3x2 r0 = uint3x2(6, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (1773486938);
+            uint3x2 b1 = uint3x2(1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637);
+            uint3x2 r1 = uint3x2(1, 21, 1, 2, 38, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (396671391);
+            uint3x2 b2 = uint3x2(784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453);
+            uint3x2 r2 = uint3x2(0, 0, 0, 0, 1, 8);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (1796936382);
+            uint3x2 b3 = uint3x2(1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083);
+            uint3x2 r3 = uint3x2(1, 1, 0, 2, 1, 5);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mod_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460);
+            uint3x2 b0 = uint3x2(983050390, 771341152, 942375212, 367361754, 749500619, 750718852);
+            uint3x2 r0 = uint3x2(146150818, 303861001, 129072544, 308965362, 659881575, 251646608);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x2 a1 = uint3x2(861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            uint3x2 b1 = uint3x2(2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            uint3x2 r1 = uint3x2(861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x2 a2 = uint3x2(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            uint3x2 b2 = uint3x2(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            uint3x2 r2 = uint3x2(137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x2 a3 = uint3x2(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint3x2 b3 = uint3x2(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint3x2 r3 = uint3x2(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mod_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208);
+            uint b0 = (883951171);
+            uint3x2 r0 = uint3x2(164800505, 178226657, 130847333, 817702147, 820393245, 19002208);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x2 a1 = uint3x2(128329633, 896587769, 405208598, 1982762194, 959236935, 712321026);
+            uint b1 = (1464010899);
+            uint3x2 r1 = uint3x2(128329633, 896587769, 405208598, 518751295, 959236935, 712321026);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x2 a2 = uint3x2(172564850, 1085897743, 1607489717, 165478511, 647846716, 915707999);
+            uint b2 = (1540068445);
+            uint3x2 r2 = uint3x2(172564850, 1085897743, 67421272, 165478511, 647846716, 915707999);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x2 a3 = uint3x2(1602830401, 1084934806, 488509689, 2087820912, 377501313, 1778384846);
+            uint b3 = (928191283);
+            uint3x2 r3 = uint3x2(674639118, 156743523, 488509689, 231438346, 377501313, 850193563);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint3x2 b0 = uint3x2(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038);
+            uint3x2 r0 = uint3x2(242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1906405167);
+            uint3x2 b1 = uint3x2(247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643);
+            uint3x2 r1 = uint3x2(172552312, 145641729, 411110001, 159757961, 314361468, 608302524);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (2057984657);
+            uint3x2 b2 = uint3x2(1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997);
+            uint3x2 r2 = uint3x2(56500475, 596612526, 198242315, 463615283, 414206973, 974791660);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (840114986);
+            uint3x2 b3 = uint3x2(1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061);
+            uint3x2 r3 = uint3x2(840114986, 224955022, 840114986, 217454, 840114986, 17224681);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_plus()
+        {
+            uint3x2 a0 = uint3x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            uint3x2 r0 = uint3x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint3x2 a1 = uint3x2(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            uint3x2 r1 = uint3x2(1472881565, 401565897, 1287765427, 849339193, 174532915, 1864850812);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint3x2 a2 = uint3x2(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            uint3x2 r2 = uint3x2(1566098441, 1615499926, 2049663954, 1723005749, 409076474, 591286416);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint3x2 a3 = uint3x2(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            uint3x2 r3 = uint3x2(1706631096, 1808261782, 1201290141, 82958939, 308695413, 1575280693);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_neg()
+        {
+            uint3x2 a0 = uint3x2(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593);
+            uint3x2 r0 = uint3x2(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint3x2 a1 = uint3x2(33894270, 1115028238, 1636274969, 694995093, 1542206286, 213087293);
+            uint3x2 r1 = uint3x2(4261073026, 3179939058, 2658692327, 3599972203, 2752761010, 4081880003);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint3x2 a2 = uint3x2(243937487, 841085242, 574159094, 1687250035, 2057919693, 1175014732);
+            uint3x2 r2 = uint3x2(4051029809, 3453882054, 3720808202, 2607717261, 2237047603, 3119952564);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint3x2 a3 = uint3x2(1259809073, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454);
+            uint3x2 r3 = uint3x2(3035158223, 3104397376, 2247011524, 2174237432, 2854192368, 2809370842);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_prefix_inc()
+        {
+            uint3x2 a0 = uint3x2(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725);
+            uint3x2 r0 = uint3x2(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint3x2 a1 = uint3x2(395072276, 913293639, 432884105, 1208161871, 1385544935, 1835605516);
+            uint3x2 r1 = uint3x2(395072277, 913293640, 432884106, 1208161872, 1385544936, 1835605517);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint3x2 a2 = uint3x2(831396561, 696475402, 1786514683, 993189311, 752093909, 1622410417);
+            uint3x2 r2 = uint3x2(831396562, 696475403, 1786514684, 993189312, 752093910, 1622410418);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint3x2 a3 = uint3x2(1398865015, 1705625817, 609525897, 172599489, 504806865, 519296647);
+            uint3x2 r3 = uint3x2(1398865016, 1705625818, 609525898, 172599490, 504806866, 519296648);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_postfix_inc()
+        {
+            uint3x2 a0 = uint3x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            uint3x2 r0 = uint3x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint3x2 a1 = uint3x2(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            uint3x2 r1 = uint3x2(1643023524, 1396179607, 708474528, 177416855, 1524860667, 1408994706);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint3x2 a2 = uint3x2(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            uint3x2 r2 = uint3x2(375284401, 1676086778, 717006530, 506142468, 732199129, 2026873940);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint3x2 a3 = uint3x2(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            uint3x2 r3 = uint3x2(130175844, 420613464, 1219979307, 586574160, 357567451, 1468020171);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_prefix_dec()
+        {
+            uint3x2 a0 = uint3x2(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037);
+            uint3x2 r0 = uint3x2(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint3x2 a1 = uint3x2(1782514098, 1434377580, 596759698, 1699290403, 1758478358, 1914114460);
+            uint3x2 r1 = uint3x2(1782514097, 1434377579, 596759697, 1699290402, 1758478357, 1914114459);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint3x2 a2 = uint3x2(71237375, 1022184392, 1310293956, 356565557, 18299409, 906734601);
+            uint3x2 r2 = uint3x2(71237374, 1022184391, 1310293955, 356565556, 18299408, 906734600);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint3x2 a3 = uint3x2(799006218, 1040798388, 1469596990, 1719228297, 220897829, 1454322707);
+            uint3x2 r3 = uint3x2(799006217, 1040798387, 1469596989, 1719228296, 220897828, 1454322706);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_postfix_dec()
+        {
+            uint3x2 a0 = uint3x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            uint3x2 r0 = uint3x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint3x2 a1 = uint3x2(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            uint3x2 r1 = uint3x2(484207852, 691209285, 2017728859, 802721301, 377162390, 526366486);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint3x2 a2 = uint3x2(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            uint3x2 r2 = uint3x2(1504625034, 60677868, 1867810045, 2095777993, 670715645, 324944916);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint3x2 a3 = uint3x2(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            uint3x2 r3 = uint3x2(242636153, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_and_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558);
+            uint3x2 b0 = uint3x2(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877);
+            uint3x2 r0 = uint3x2(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x2 a1 = uint3x2(1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            uint3x2 b1 = uint3x2(1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            uint3x2 r1 = uint3x2(1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x2 a2 = uint3x2(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            uint3x2 b2 = uint3x2(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            uint3x2 r2 = uint3x2(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x2 a3 = uint3x2(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint3x2 b3 = uint3x2(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint3x2 r3 = uint3x2(168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_and_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004);
+            uint b0 = (93423598);
+            uint3x2 r0 = uint3x2(1114348, 85033216, 26281518, 8488942, 25232710, 67176356);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x2 a1 = uint3x2(1941875181, 1365509729, 428270198, 607982857, 650270920, 1249238550);
+            uint b1 = (1236735839);
+            uint3x2 r1 = uint3x2(1102446925, 1092879937, 159777366, 3478793, 8523848, 1211438614);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x2 a2 = uint3x2(814629680, 143502472, 861733033, 1408932942, 957693145, 1567715668);
+            uint b2 = (1862276471);
+            uint3x2 r2 = uint3x2(536871216, 134218752, 587202593, 1124078662, 687871057, 1291850068);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x2 a3 = uint3x2(1102952410, 1599352836, 208656708, 1272226025, 462670926, 1817145060);
+            uint b3 = (322053683);
+            uint3x2 r3 = uint3x2(19932690, 319823872, 2228224, 51388449, 319947778, 140832);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint3x2 b0 = uint3x2(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958);
+            uint3x2 r0 = uint3x2(547170, 18752, 1074284806, 1140867104, 3672064, 3168358);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1159378889);
+            uint3x2 b1 = uint3x2(2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957);
+            uint3x2 r1 = uint3x2(1091605257, 1074836865, 9161, 1074299840, 83924360, 1092133121);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1248975349);
+            uint3x2 b2 = uint3x2(236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522);
+            uint3x2 r2 = uint3x2(168903041, 167844145, 1075925380, 1241581744, 140613985, 1074872496);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (2042776519);
+            uint3x2 b3 = uint3x2(56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404);
+            uint3x2 r3 = uint3x2(21118982, 1770146496, 1769996867, 1371555910, 1229064577, 1212170948);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_or_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514);
+            uint3x2 b0 = uint3x2(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212);
+            uint3x2 r0 = uint3x2(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x2 a1 = uint3x2(948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            uint3x2 b1 = uint3x2(2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            uint3x2 r1 = uint3x2(2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x2 a2 = uint3x2(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            uint3x2 b2 = uint3x2(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            uint3x2 r2 = uint3x2(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x2 a3 = uint3x2(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint3x2 b3 = uint3x2(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint3x2 r3 = uint3x2(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_or_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449);
+            uint b0 = (1666102508);
+            uint3x2 r0 = uint3x2(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x2 a1 = uint3x2(1048929715, 860336789, 1637162093, 1227888278, 774029856, 879300408);
+            uint b1 = (1814263250);
+            uint3x2 r1 = uint3x2(2124903923, 2137520087, 1840741887, 1832089558, 1847850994, 2087419898);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x2 a2 = uint3x2(1179087439, 1977614655, 46921989, 1980838747, 284225881, 64304104);
+            uint b2 = (797240690);
+            uint3x2 r2 = uint3x2(1875378047, 2145709439, 802159991, 2140536699, 1073020283, 802553850);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x2 a3 = uint3x2(313591807, 1890090886, 521303722, 2021379070, 2055963359, 1511253082);
+            uint b3 = (1393862490);
+            uint3x2 r3 = uint3x2(1404413951, 1941766110, 1595340794, 2071982078, 2074060767, 1528293210);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint3x2 b0 = uint3x2(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481);
+            uint3x2 r0 = uint3x2(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (1283571271);
+            uint3x2 b1 = uint3x2(2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741);
+            uint3x2 r1 = uint3x2(2109210439, 2128723919, 1558052575, 1608908663, 1838415447, 2141322991);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (627815046);
+            uint3x2 b2 = uint3x2(418822515, 83214352, 424663473, 447949225, 527022375, 1947148461);
+            uint3x2 r2 = uint3x2(1040169975, 637530774, 1030749111, 1073462191, 1064024999, 1970254511);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (305251437);
+            uint3x2 b3 = uint3x2(1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808);
+            uint3x2 r3 = uint3x2(1526199917, 2054417661, 1593566973, 1589235437, 1391839215, 335281389);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_xor_wide_wide()
+        {
+            uint3x2 a0 = uint3x2(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585);
+            uint3x2 b0 = uint3x2(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205);
+            uint3x2 r0 = uint3x2(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x2 a1 = uint3x2(220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            uint3x2 b1 = uint3x2(535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            uint3x2 r1 = uint3x2(314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x2 a2 = uint3x2(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            uint3x2 b2 = uint3x2(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            uint3x2 r2 = uint3x2(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x2 a3 = uint3x2(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint3x2 b3 = uint3x2(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint3x2 r3 = uint3x2(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_xor_wide_scalar()
+        {
+            uint3x2 a0 = uint3x2(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690);
+            uint b0 = (493665894);
+            uint3x2 r0 = uint3x2(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x2 a1 = uint3x2(535061373, 1305234431, 353786540, 1308626970, 1267729267, 125659640);
+            uint b1 = (289301586);
+            uint3x2 r1 = uint3x2(249169711, 1559375789, 69746430, 1597928520, 1521379105, 373493162);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x2 a2 = uint3x2(1315625690, 116862046, 375757978, 491079274, 191750702, 187129429);
+            uint b2 = (1730088797);
+            uint3x2 r2 = uint3x2(695588231, 1642603267, 1903858631, 2052737335, 1819471219, 1815630088);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x2 a3 = uint3x2(967051293, 653124416, 788984, 1479174924, 1680011736, 447453839);
+            uint b3 = (549951551);
+            uint3x2 r3 = uint3x2(425955362, 103447423, 550212039, 2028860211, 1155885543, 980157104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint3x2 b0 = uint3x2(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275);
+            uint3x2 r0 = uint3x2(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1416249064);
+            uint3x2 b1 = uint3x2(1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003);
+            uint3x2 r1 = uint3x2(442541185, 1037166305, 227827390, 327742460, 280796832, 544217587);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1774252400);
+            uint3x2 b2 = uint3x2(1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053);
+            uint3x2 r2 = uint3x2(440379266, 698081028, 2022864761, 1000608691, 1580745115, 667852101);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (221134131);
+            uint3x2 b3 = uint3x2(885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520);
+            uint3x2 r3 = uint3x2(971170309, 693458543, 113181510, 1584258954, 790500762, 1630705027);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_left_shift()
+        {
+            uint3x2 a0 = uint3x2(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717);
+            int b0 = (1321149625);
+            uint3x2 r0 = uint3x2(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint3x2 a1 = uint3x2(870301196, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302);
+            int b1 = (2058433484);
+            uint3x2 r1 = uint3x2(4225810432, 306012160, 2812907520, 20340736, 2519031808, 2733760512);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint3x2 a2 = uint3x2(1079614371, 1664454606, 2045594989, 2077023268, 592678686, 297755411);
+            int b2 = (35667343);
+            uint3x2 r2 = uint3x2(3453059072, 3353804800, 2796978176, 1846673408, 3348037632, 2978578432);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint3x2 a3 = uint3x2(1722762487, 37265945, 997793693, 1521705181, 263886278, 221147365);
+            int b3 = (1161625759);
+            uint3x2 r3 = uint3x2(2147483648, 2147483648, 2147483648, 2147483648, 0, 2147483648);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_right_shift()
+        {
+            uint3x2 a0 = uint3x2(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656);
+            int b0 = (1266801540);
+            uint3x2 r0 = uint3x2(34260456, 72583643, 101101614, 116295740, 44622419, 12284541);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint3x2 a1 = uint3x2(770466193, 572763124, 506619530, 426807581, 2031319045, 701927980);
+            int b1 = (1265099998);
+            uint3x2 r1 = uint3x2(0, 0, 0, 0, 1, 0);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint3x2 a2 = uint3x2(917785020, 185593382, 1102123711, 334005460, 1624751550, 280138733);
+            int b2 = (569504877);
+            uint3x2 r2 = uint3x2(112034, 22655, 134536, 40772, 198333, 34196);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint3x2 a3 = uint3x2(1598620011, 736389149, 1279158873, 408822762, 763607760, 348013684);
+            int b3 = (1840564178);
+            uint3x2 r3 = uint3x2(6098, 2809, 4879, 1559, 2912, 1327);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x2_operator_bitwise_not()
+        {
+            uint3x2 a0 = uint3x2(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339);
+            uint3x2 r0 = uint3x2(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint3x2 a1 = uint3x2(1935567517, 472965491, 771711426, 627580960, 2061524024, 753208488);
+            uint3x2 r1 = uint3x2(2359399778, 3822001804, 3523255869, 3667386335, 2233443271, 3541758807);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint3x2 a2 = uint3x2(2097179283, 664744603, 1289372466, 1635981125, 1951018596, 1545651937);
+            uint3x2 r2 = uint3x2(2197788012, 3630222692, 3005594829, 2658986170, 2343948699, 2749315358);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint3x2 a3 = uint3x2(717936457, 1342785385, 869629475, 2045854321, 1282546942, 1562433528);
+            uint3x2 r3 = uint3x2(3577030838, 2952181910, 3425337820, 2249112974, 3012420353, 2732533767);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..43cda1bdad5defc5312c169903cfdb5b9c04cbfa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bede9ed05d973fa43bff7c97121eab82
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..86e0bb6dffd763fc02810658bc364509ffcccfc2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs
@@ -0,0 +1,1244 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint3x3
+    {
+        [TestCompiler]
+        public static void uint3x3_zero()
+        {
+            TestUtils.AreEqual(uint3x3.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c1.z, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c2.y, 0u);
+            TestUtils.AreEqual(uint3x3.zero.c2.z, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_identity()
+        {
+            TestUtils.AreEqual(uint3x3.identity.c0.x, 1u);
+            TestUtils.AreEqual(uint3x3.identity.c0.y, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c0.z, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c1.x, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c1.y, 1u);
+            TestUtils.AreEqual(uint3x3.identity.c1.z, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c2.x, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c2.y, 0u);
+            TestUtils.AreEqual(uint3x3.identity.c2.z, 1u);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_equal_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268);
+            uint3x3 b0 = uint3x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x3 a1 = uint3x3(1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206);
+            uint3x3 b1 = uint3x3(2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x3 a2 = uint3x3(1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509, 1025529486, 2095601864, 193500113);
+            uint3x3 b2 = uint3x3(1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580, 708665810, 1902328998, 1808456602);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x3 a3 = uint3x3(1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            uint3x3 b3 = uint3x3(563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_equal_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538);
+            uint b0 = (746972502);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x3 a1 = uint3x3(795585660, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077, 442746747, 1772925698);
+            uint b1 = (936027116);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x3 a2 = uint3x3(1884034177, 425476075, 1370577708, 597010220, 1249636005, 211986678, 1305479811, 255635293, 1150443719);
+            uint b2 = (451512860);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x3 a3 = uint3x3(177122433, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291, 872759249);
+            uint b3 = (511346787);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint3x3 b0 = uint3x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787);
+            bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1009011238);
+            uint3x3 b1 = uint3x3(312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (534746610);
+            uint3x3 b2 = uint3x3(559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403, 1839429063, 223575614);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (79701214);
+            uint3x3 b3 = uint3x3(1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415, 1576985758);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_not_equal_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135);
+            uint3x3 b0 = uint3x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x3 a1 = uint3x3(1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665);
+            uint3x3 b1 = uint3x3(1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x3 a2 = uint3x3(1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890, 922313145, 2006448607, 1574579050);
+            uint3x3 b2 = uint3x3(687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634, 1944210269, 92849031, 164029425);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x3 a3 = uint3x3(1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            uint3x3 b3 = uint3x3(628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_not_equal_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247);
+            uint b0 = (248693828);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x3 a1 = uint3x3(727205263, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883, 1622176923, 768370497);
+            uint b1 = (1640688041);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x3 a2 = uint3x3(1072798259, 1497830076, 1582645163, 1876273820, 90244766, 30493685, 904014575, 384643370, 11554610);
+            uint b2 = (1808712713);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x3 a3 = uint3x3(2016093187, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113, 765258490);
+            uint b3 = (1515760622);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint3x3 b0 = uint3x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (1512967900);
+            uint3x3 b1 = uint3x3(1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (1826089250);
+            uint3x3 b2 = uint3x3(1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024, 1936481966, 1366859342);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1775285431);
+            uint3x3 b3 = uint3x3(604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666, 358894860);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233);
+            uint3x3 b0 = uint3x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337);
+            bool3x3 r0 = bool3x3(false, true, false, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x3 a1 = uint3x3(789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052);
+            uint3x3 b1 = uint3x3(1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723);
+            bool3x3 r1 = bool3x3(true, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x3 a2 = uint3x3(778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162, 1638101724, 2044698552, 1543260981);
+            uint3x3 b2 = uint3x3(1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133, 271967348, 1601249324, 1373999400);
+            bool3x3 r2 = bool3x3(true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x3 a3 = uint3x3(471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            uint3x3 b3 = uint3x3(1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool3x3 r3 = bool3x3(true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491);
+            uint b0 = (1491216667);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x3 a1 = uint3x3(469591900, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709, 1286331950, 380753337);
+            uint b1 = (1247103789);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x3 a2 = uint3x3(971148054, 1056649851, 1579735991, 689044913, 1960894027, 371987110, 867559111, 1703747625, 1698536333);
+            uint b2 = (1827886929);
+            bool3x3 r2 = bool3x3(true, true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x3 a3 = uint3x3(41716206, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606, 1891059504);
+            uint b3 = (243673862);
+            bool3x3 r3 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint3x3 b0 = uint3x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251);
+            bool3x3 r0 = bool3x3(false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1102440676);
+            uint3x3 b1 = uint3x3(112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (358911716);
+            uint3x3 b2 = uint3x3(874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911, 1276652605, 593690439);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (771851138);
+            uint3x3 b3 = uint3x3(590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916, 168788814);
+            bool3x3 r3 = bool3x3(false, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537);
+            uint3x3 b0 = uint3x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808);
+            bool3x3 r0 = bool3x3(true, true, false, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x3 a1 = uint3x3(1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424);
+            uint3x3 b1 = uint3x3(976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x3 a2 = uint3x3(348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622, 1295065160, 715285504, 1130323487);
+            uint3x3 b2 = uint3x3(1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265, 335209251, 1094341422, 1465325455);
+            bool3x3 r2 = bool3x3(false, false, false, true, true, true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x3 a3 = uint3x3(677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            uint3x3 b3 = uint3x3(390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool3x3 r3 = bool3x3(true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448);
+            uint b0 = (438688675);
+            bool3x3 r0 = bool3x3(true, false, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x3 a1 = uint3x3(304028799, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211, 2063134811, 1577403353);
+            uint b1 = (893125636);
+            bool3x3 r1 = bool3x3(false, false, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x3 a2 = uint3x3(64009107, 1143565920, 3715845, 689362811, 263973424, 1045140419, 1058332184, 524569092, 1183316983);
+            uint b2 = (1462961460);
+            bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x3 a3 = uint3x3(1107974092, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732, 1284938191);
+            uint b3 = (212839726);
+            bool3x3 r3 = bool3x3(true, true, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint3x3 b0 = uint3x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512);
+            bool3x3 r0 = bool3x3(true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (741776730);
+            uint3x3 b1 = uint3x3(732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907);
+            bool3x3 r1 = bool3x3(true, true, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1858177345);
+            uint3x3 b2 = uint3x3(299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296, 292652611, 1002628348);
+            bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (927789921);
+            uint3x3 b3 = uint3x3(108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261, 267985383);
+            bool3x3 r3 = bool3x3(true, true, false, false, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_equal_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003);
+            uint3x3 b0 = uint3x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766);
+            bool3x3 r0 = bool3x3(false, true, false, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x3 a1 = uint3x3(1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822);
+            uint3x3 b1 = uint3x3(1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315);
+            bool3x3 r1 = bool3x3(false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x3 a2 = uint3x3(1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884, 912169992, 1992682021, 1619593455);
+            uint3x3 b2 = uint3x3(1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017, 620752145, 1213693681, 1281818305);
+            bool3x3 r2 = bool3x3(true, false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x3 a3 = uint3x3(1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            uint3x3 b3 = uint3x3(1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_equal_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706);
+            uint b0 = (1688048545);
+            bool3x3 r0 = bool3x3(false, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x3 a1 = uint3x3(1745758438, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948, 2017733017, 804204255);
+            uint b1 = (532949158);
+            bool3x3 r1 = bool3x3(false, true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x3 a2 = uint3x3(981729559, 910922522, 2079225209, 26179915, 238796519, 1917813750, 1258115260, 20607406, 1337879822);
+            uint b2 = (2032949254);
+            bool3x3 r2 = bool3x3(true, true, false, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x3 a3 = uint3x3(959460446, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244, 426908235);
+            uint b3 = (1599429457);
+            bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint3x3 b0 = uint3x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (11953554);
+            uint3x3 b1 = uint3x3(1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (957887737);
+            uint3x3 b2 = uint3x3(117849810, 1348693584, 105489302, 259034238, 530713566, 601413850, 830430286, 145552297, 1697295044);
+            bool3x3 r2 = bool3x3(false, true, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (1150680564);
+            uint3x3 b3 = uint3x3(2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260, 733876180);
+            bool3x3 r3 = bool3x3(true, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_equal_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730);
+            uint3x3 b0 = uint3x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580);
+            bool3x3 r0 = bool3x3(false, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x3 a1 = uint3x3(1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484);
+            uint3x3 b1 = uint3x3(1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918);
+            bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x3 a2 = uint3x3(744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474, 605043041, 1707339660, 2038122892);
+            uint3x3 b2 = uint3x3(1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253, 2025187918, 750755999, 869709740);
+            bool3x3 r2 = bool3x3(false, true, false, true, false, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x3 a3 = uint3x3(345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            uint3x3 b3 = uint3x3(1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool3x3 r3 = bool3x3(false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_equal_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196);
+            uint b0 = (1470533736);
+            bool3x3 r0 = bool3x3(true, false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x3 a1 = uint3x3(1604309397, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021, 196833647, 1596738181);
+            uint b1 = (829548642);
+            bool3x3 r1 = bool3x3(true, false, true, false, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x3 a2 = uint3x3(1905036391, 1584946560, 370941146, 440219668, 1607345862, 1449142607, 1223010129, 379014762, 1719435169);
+            uint b2 = (1771391775);
+            bool3x3 r2 = bool3x3(true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x3 a3 = uint3x3(258833609, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895, 192092521);
+            uint b3 = (1389585003);
+            bool3x3 r3 = bool3x3(false, false, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint3x3 b0 = uint3x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990);
+            bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (1947039008);
+            uint3x3 b1 = uint3x3(1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577, 173706579, 625318949);
+            bool3x3 r1 = bool3x3(true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (519443238);
+            uint3x3 b2 = uint3x3(1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308, 479913036, 984991199);
+            bool3x3 r2 = bool3x3(false, false, false, true, false, false, true, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (172993285);
+            uint3x3 b3 = uint3x3(2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513, 474197678);
+            bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_add_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704);
+            uint3x3 b0 = uint3x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231);
+            uint3x3 r0 = uint3x3(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161, 2285462935);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x3 a1 = uint3x3(192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141);
+            uint3x3 b1 = uint3x3(908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019);
+            uint3x3 r1 = uint3x3(1101613923, 3495777492, 1384643660, 4147356693, 749502583, 623052937, 3113339623, 2178242226, 3146426160);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x3 a2 = uint3x3(997691756, 857841794, 2129024875, 267535529, 978891383, 657092366, 941872903, 906908654, 1940071697);
+            uint3x3 b2 = uint3x3(776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905, 2106992817, 1994483489, 539473);
+            uint3x3 r2 = uint3x3(1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271, 3048865720, 2901392143, 1940611170);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x3 a3 = uint3x3(862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            uint3x3 b3 = uint3x3(236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            uint3x3 r3 = uint3x3(1099044556, 2362767916, 1285092016, 2641863205, 3757383291, 604086579, 2150755997, 3626413591, 2674116169);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_add_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861);
+            uint b0 = (2124409227);
+            uint3x3 r0 = uint3x3(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528, 4127431088);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x3 a1 = uint3x3(1635971971, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654, 756559204, 1818718931);
+            uint b1 = (1160398286);
+            uint3x3 r1 = uint3x3(2796370257, 1245844488, 2228551252, 2399785386, 2658075174, 2887875771, 2255836940, 1916957490, 2979117217);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x3 a2 = uint3x3(658923552, 1585755398, 692843300, 1068593469, 1704776233, 577782260, 736972565, 711894571, 564257439);
+            uint b2 = (1610518921);
+            uint3x3 r2 = uint3x3(2269442473, 3196274319, 2303362221, 2679112390, 3315295154, 2188301181, 2347491486, 2322413492, 2174776360);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x3 a3 = uint3x3(2051736283, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190, 2092767444);
+            uint b3 = (1572837697);
+            uint3x3 r3 = uint3x3(3624573980, 3200844242, 3428537960, 2229586479, 1845612213, 3489970896, 2401160670, 3689647887, 3665605141);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint3x3 b0 = uint3x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825);
+            uint3x3 r0 = uint3x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150, 1387123903);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (1557774949);
+            uint3x3 b1 = uint3x3(779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874);
+            uint3x3 r1 = uint3x3(2337549889, 2669316251, 2340821394, 2687938893, 1846054533, 2955458810, 3194358438, 2231038288, 3027075823);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (14855965);
+            uint3x3 b2 = uint3x3(1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835, 1992405574, 1213924458);
+            uint3x3 r2 = uint3x3(1131492964, 1503719265, 1615846851, 205507266, 1322315733, 934941804, 2097085800, 2007261539, 1228780423);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (505841452);
+            uint3x3 b3 = uint3x3(981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886, 1459523189);
+            uint3x3 r3 = uint3x3(1487262614, 1994179151, 1619668092, 2311987960, 2347632674, 712452303, 1032813405, 1742201338, 1965364641);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_sub_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185);
+            uint3x3 b0 = uint3x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303);
+            uint3x3 r0 = uint3x3(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549, 1234495882);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x3 a1 = uint3x3(579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611);
+            uint3x3 b1 = uint3x3(1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956, 632054793, 711091688);
+            uint3x3 r1 = uint3x3(3456019244, 3562788131, 3413504982, 4244761393, 3364773944, 120810088, 929308315, 3670565287, 4129068219);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x3 a2 = uint3x3(176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454, 425848588, 2026967474, 1128492011);
+            uint3x3 b2 = uint3x3(904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855, 609588723, 1054324682, 1678086165);
+            uint3x3 r2 = uint3x3(3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895, 4111227161, 972642792, 3745373142);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x3 a3 = uint3x3(61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            uint3x3 b3 = uint3x3(1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            uint3x3 r3 = uint3x3(2826807304, 3564332942, 1218011798, 1846728662, 3739059778, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_sub_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200);
+            uint b0 = (462232403);
+            uint3x3 r0 = uint3x3(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412, 4113909093);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x3 a1 = uint3x3(87530840, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635, 815920639, 1829033117);
+            uint b1 = (1913724431);
+            uint3x3 r1 = uint3x3(2468773705, 127868905, 2938482855, 3500294313, 3971619597, 3200333054, 3197625500, 3197163504, 4210275982);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x3 a2 = uint3x3(1792801932, 1418937976, 1277257189, 2092779398, 642236742, 1605250794, 819644478, 1468003019, 128303186);
+            uint b2 = (1113440549);
+            uint3x3 r2 = uint3x3(679361383, 305497427, 163816640, 979338849, 3823763489, 491810245, 4001171225, 354562470, 3309829933);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x3 a3 = uint3x3(553494257, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204, 1835969317);
+            uint b3 = (1017126971);
+            uint3x3 r3 = uint3x3(3831334582, 982617811, 1000145787, 800864793, 263858529, 3954815180, 620905642, 4227601529, 818842346);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint3x3 b0 = uint3x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421);
+            uint3x3 r0 = uint3x3(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128, 4197201280);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (264712893);
+            uint3x3 b1 = uint3x3(1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254);
+            uint3x3 r1 = uint3x3(3327824122, 2741567441, 3131244080, 3300934729, 3482299793, 3228957470, 4041568360, 3592551660, 4215013935);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (1082267918);
+            uint3x3 b2 = uint3x3(907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777, 730060552, 1444397827);
+            uint3x3 r2 = uint3x3(174401222, 3560350091, 621927350, 120113420, 525154457, 3676018505, 3397136437, 352207366, 3932837387);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (853570556);
+            uint3x3 b3 = uint3x3(138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026, 902880656);
+            uint3x3 r3 = uint3x3(714734124, 4135347424, 135481026, 346813166, 3932089811, 4212225105, 3151251397, 3178555826, 4245657196);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mul_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445);
+            uint3x3 b0 = uint3x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331);
+            uint3x3 r0 = uint3x3(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228, 2640799263);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x3 a1 = uint3x3(1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675);
+            uint3x3 b1 = uint3x3(1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359);
+            uint3x3 r1 = uint3x3(2093463192, 3087460678, 3161406466, 990589280, 3356793344, 2953243830, 1156600361, 649177976, 678952165);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x3 a2 = uint3x3(853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234, 899438811, 1765718681, 409003054);
+            uint3x3 b2 = uint3x3(1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952, 675813713, 999254223, 1326064110);
+            uint3x3 r2 = uint3x3(1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720, 1891467339, 335415735, 1128927428);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x3 a3 = uint3x3(2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            uint3x3 b3 = uint3x3(788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            uint3x3 r3 = uint3x3(2638713520, 2861115658, 479369680, 3928339236, 4044803354, 48406862, 2297104000, 4019846068, 2811510105);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mul_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632);
+            uint b0 = (1476837906);
+            uint3x3 r0 = uint3x3(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778, 1736252960);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x3 a1 = uint3x3(573770299, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467, 1186856590, 890343818);
+            uint b1 = (1958912969);
+            uint3x3 r1 = uint3x3(3595344211, 583613531, 2609540870, 377032876, 2454084431, 3835667937, 506042323, 3286058878, 2903122778);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x3 a2 = uint3x3(800117742, 1338014500, 1688964615, 1439447294, 387721300, 1192501703, 1613845584, 76318055, 124378112);
+            uint b2 = (606927173);
+            uint3x3 r2 = uint3x3(3182664998, 4040635572, 1687557859, 1193437814, 1547735716, 2273028515, 2785905040, 1364534211, 3330558976);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x3 a3 = uint3x3(970518733, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648, 227492421);
+            uint b3 = (1370700538);
+            uint3x3 r3 = uint3x3(3770718770, 45251204, 2784815084, 28492454, 1649233534, 4185812774, 2668749740, 1373293008, 3727251810);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint3x3 b0 = uint3x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483);
+            uint3x3 r0 = uint3x3(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328, 1623617844);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1178393968);
+            uint3x3 b1 = uint3x3(1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535);
+            uint3x3 r1 = uint3x3(1196573760, 592673296, 209320208, 3942500560, 1007302672, 3390780416, 3294337904, 2248146480, 1026909584);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1821413700);
+            uint3x3 b2 = uint3x3(677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236, 657101857, 1275563580);
+            uint3x3 r2 = uint3x3(118306580, 1091472052, 1879587908, 2176549780, 4108343324, 1015975816, 1406756912, 3284535748, 3411133424);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (1031291523);
+            uint3x3 b3 = uint3x3(1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263, 2022856151);
+            uint3x3 r3 = uint3x3(2179584169, 2776004243, 358436435, 3342466462, 469974843, 2393957023, 2519661334, 1424675509, 3838532357);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_div_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351);
+            uint3x3 b0 = uint3x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057);
+            uint3x3 r0 = uint3x3(1, 0, 0, 8, 0, 0, 2, 7, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x3 a1 = uint3x3(1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018);
+            uint3x3 b1 = uint3x3(254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708, 896853614, 49452028);
+            uint3x3 r1 = uint3x3(5, 0, 0, 0, 2, 1, 2, 1, 39);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x3 a2 = uint3x3(645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343, 1735128704, 816492592, 2012272185);
+            uint3x3 b2 = uint3x3(1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844, 616122946, 2035322800, 1324534444);
+            uint3x3 r2 = uint3x3(0, 1, 1, 1, 1, 0, 2, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x3 a3 = uint3x3(632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            uint3x3 b3 = uint3x3(1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            uint3x3 r3 = uint3x3(0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_div_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568);
+            uint b0 = (947861580);
+            uint3x3 r0 = uint3x3(0, 1, 0, 1, 2, 1, 1, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x3 a1 = uint3x3(495895326, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372, 1447236569, 107215658);
+            uint b1 = (1515313790);
+            uint3x3 r1 = uint3x3(0, 1, 1, 1, 0, 0, 1, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x3 a2 = uint3x3(19616726, 707389627, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864, 1200843642, 206442634);
+            uint b2 = (896899915);
+            uint3x3 r2 = uint3x3(0, 0, 1, 1, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x3 a3 = uint3x3(1508567412, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918, 1515555001);
+            uint b3 = (1825701056);
+            uint3x3 r3 = uint3x3(0, 0, 0, 0, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint3x3 b0 = uint3x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373);
+            uint3x3 r0 = uint3x3(6, 0, 0, 0, 2, 0, 0, 1, 14);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (1476877645);
+            uint3x3 b1 = uint3x3(653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729);
+            uint3x3 r1 = uint3x3(2, 32, 2, 3, 1, 1, 0, 0, 5);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (48974453);
+            uint3x3 b2 = uint3x3(1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083, 131970646, 1320586926);
+            uint3x3 r2 = uint3x3(0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (366944102);
+            uint3x3 b3 = uint3x3(1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534, 126616016);
+            uint3x3 r3 = uint3x3(0, 1, 0, 0, 0, 8, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mod_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078);
+            uint3x3 b0 = uint3x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442);
+            uint3x3 r0 = uint3x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x3 a1 = uint3x3(1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255);
+            uint3x3 b1 = uint3x3(647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784);
+            uint3x3 r1 = uint3x3(164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301, 7646243, 10787903);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x3 a2 = uint3x3(1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189, 1402964707, 2138294579, 1641714420);
+            uint3x3 b2 = uint3x3(1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748, 798137669, 79717779, 1233582258);
+            uint3x3 r2 = uint3x3(290237779, 556971011, 100255877, 123540972, 1545968777, 629019189, 604827038, 65632325, 408132162);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x3 a3 = uint3x3(1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            uint3x3 b3 = uint3x3(1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            uint3x3 r3 = uint3x3(514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mod_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769);
+            uint b0 = (883951171);
+            uint3x3 r0 = uint3x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x3 a1 = uint3x3(405208598, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717, 165478511, 647846716);
+            uint b1 = (1982762194);
+            uint3x3 r1 = uint3x3(405208598, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717, 165478511, 647846716);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x3 a2 = uint3x3(915707999, 928191283, 1084934806, 488509689, 2087820912, 377501313, 1778384846, 1216011754, 812183417);
+            uint b2 = (1602830401);
+            uint3x3 r2 = uint3x3(915707999, 928191283, 1084934806, 488509689, 484990511, 377501313, 175554445, 1216011754, 812183417);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x3 a3 = uint3x3(1153802502, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372, 586777590);
+            uint b3 = (1642671870);
+            uint3x3 r3 = uint3x3(1153802502, 282038872, 665297470, 1568090825, 408311072, 435886407, 453990946, 88993502, 586777590);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint3x3 b0 = uint3x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573);
+            uint3x3 r0 = uint3x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1495295166);
+            uint3x3 b1 = uint3x3(873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842);
+            uint3x3 r1 = uint3x3(621971563, 433932700, 197192523, 1495295166, 494553075, 33923035, 1495295166, 698110479, 673406324);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (1083192997);
+            uint3x3 b2 = uint3x3(840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061, 730088119, 1444946139);
+            uint3x3 r2 = uint3x3(243078011, 1083192997, 468033033, 1083192997, 1875643, 1083192997, 95724631, 353104878, 1083192997);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1305792037);
+            uint3x3 b3 = uint3x3(1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894, 1342085447);
+            uint3x3 r3 = uint3x3(194963026, 433068456, 137860321, 1305792037, 282934571, 1305792037, 1305792037, 63018673, 1305792037);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_plus()
+        {
+            uint3x3 a0 = uint3x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897);
+            uint3x3 r0 = uint3x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint3x3 a1 = uint3x3(1287765427, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954, 1723005749, 409076474);
+            uint3x3 r1 = uint3x3(1287765427, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint3x3 a2 = uint3x3(591286416, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612);
+            uint3x3 r2 = uint3x3(591286416, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint3x3 a3 = uint3x3(500666137, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485, 1012749225);
+            uint3x3 r3 = uint3x3(500666137, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485, 1012749225);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_neg()
+        {
+            uint3x3 a0 = uint3x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238);
+            uint3x3 r0 = uint3x3(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947, 3179939058);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint3x3 a1 = uint3x3(1636274969, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094, 1687250035, 2057919693);
+            uint3x3 r1 = uint3x3(2658692327, 2752761010, 4081880003, 4051029809, 3953445021, 3453882054, 3720808202, 2607717261, 2237047603);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint3x3 a2 = uint3x3(1175014732, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454, 431666091, 1387601718);
+            uint3x3 r2 = uint3x3(3119952564, 3082501970, 3104397376, 2247011524, 2174237432, 2854192368, 2809370842, 3863301205, 2907365578);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint3x3 a3 = uint3x3(1745651998, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868, 650922971);
+            uint3x3 r3 = uint3x3(2549315298, 3175007490, 3555835012, 2340793982, 2585110198, 2458456246, 2632160843, 3788822428, 3644044325);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_prefix_inc()
+        {
+            uint3x3 a0 = uint3x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639);
+            uint3x3 r0 = uint3x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint3x3 a1 = uint3x3(432884105, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683, 993189311, 752093909);
+            uint3x3 r1 = uint3x3(432884106, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint3x3 a2 = uint3x3(1622410417, 241906003, 1705625817, 609525897, 172599489, 504806865, 519296647, 281942776, 1541894135);
+            uint3x3 r2 = uint3x3(1622410418, 241906004, 1705625818, 609525898, 172599490, 504806866, 519296648, 281942777, 1541894136);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint3x3 a3 = uint3x3(924683935, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111, 1414867743);
+            uint3x3 r3 = uint3x3(924683936, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112, 1414867744);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_postfix_inc()
+        {
+            uint3x3 a0 = uint3x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607);
+            uint3x3 r0 = uint3x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint3x3 a1 = uint3x3(708474528, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530, 506142468, 732199129);
+            uint3x3 r1 = uint3x3(708474528, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint3x3 a2 = uint3x3(2026873940, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901);
+            uint3x3 r2 = uint3x3(2026873940, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint3x3 a3 = uint3x3(101238629, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730, 1209169651);
+            uint3x3 r3 = uint3x3(101238629, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730, 1209169651);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_prefix_dec()
+        {
+            uint3x3 a0 = uint3x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580);
+            uint3x3 r0 = uint3x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint3x3 a1 = uint3x3(596759698, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956, 356565557, 18299409);
+            uint3x3 r1 = uint3x3(596759697, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint3x3 a2 = uint3x3(906734601, 1383897383, 1040798388, 1469596990, 1719228297, 220897829, 1454322707, 678025545, 14227726);
+            uint3x3 r2 = uint3x3(906734600, 1383897382, 1040798387, 1469596989, 1719228296, 220897828, 1454322706, 678025544, 14227725);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint3x3 a3 = uint3x3(293093918, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380, 2083512379);
+            uint3x3 r3 = uint3x3(293093917, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379, 2083512378);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_postfix_dec()
+        {
+            uint3x3 a0 = uint3x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285);
+            uint3x3 r0 = uint3x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint3x3 a1 = uint3x3(2017728859, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045, 2095777993, 670715645);
+            uint3x3 r1 = uint3x3(2017728859, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint3x3 a2 = uint3x3(324944916, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377);
+            uint3x3 r2 = uint3x3(324944916, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint3x3 a3 = uint3x3(181847458, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130, 2016700604);
+            uint3x3 r3 = uint3x3(181847458, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130, 2016700604);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_and_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114);
+            uint3x3 b0 = uint3x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139);
+            uint3x3 r0 = uint3x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x3 a1 = uint3x3(1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345);
+            uint3x3 b1 = uint3x3(1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077);
+            uint3x3 r1 = uint3x3(1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x3 a2 = uint3x3(406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372, 181537307, 130347414, 1240828622);
+            uint3x3 b2 = uint3x3(642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586, 1855189321, 185194029, 810374380);
+            uint3x3 r2 = uint3x3(168582, 1107890178, 67125280, 880844837, 541065292, 337646976, 177340425, 50384900, 4522188);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x3 a3 = uint3x3(526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            uint3x3 b3 = uint3x3(133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            uint3x3 r3 = uint3x3(122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_and_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729);
+            uint b0 = (93423598);
+            uint3x3 r0 = uint3x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x3 a1 = uint3x3(428270198, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033, 1408932942, 957693145);
+            uint b1 = (607982857);
+            uint3x3 r1 = uint3x3(262144, 603983880, 3478528, 537657600, 603985153, 853000, 538771465, 3675144, 538252297);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x3 a2 = uint3x3(1567715668, 322053683, 1599352836, 208656708, 1272226025, 462670926, 1817145060, 1466722981, 1817277774);
+            uint b2 = (1102952410);
+            uint3x3 r2 = uint3x3(1093742928, 19932690, 1091842048, 2986304, 1100259528, 26313802, 1074603712, 1093411456, 1074869578);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x3 a3 = uint3x3(818900583, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061, 398141788);
+            uint b3 = (772681077);
+            uint3x3 r3 = uint3x3(537799781, 537788480, 537527636, 604374309, 67241029, 705568773, 671747424, 167912453, 101329236);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint3x3 b0 = uint3x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981);
+            uint3x3 r0 = uint3x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (270607307);
+            uint3x3 b1 = uint3x3(1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961);
+            uint3x3 r1 = uint3x3(270533570, 268501384, 8449, 2163137, 74123, 74507, 2163594, 66184, 270598977);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1436238522);
+            uint3x3 b2 = uint3x3(2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404, 2255485, 1814885263);
+            uint3x3 r2 = uint3x3(1367491202, 18563090, 1099055776, 1167655482, 1434992658, 1092288688, 1075397272, 148024, 1141392010);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1711986588);
+            uint3x3 b3 = uint3x3(1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007, 1808619374);
+            uint3x3 r3 = uint3x3(1140883976, 637536128, 1711801728, 101224968, 1610633224, 67682712, 1644860304, 67814532, 1644713740);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_or_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222);
+            uint3x3 b0 = uint3x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169);
+            uint3x3 r0 = uint3x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x3 a1 = uint3x3(396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993);
+            uint3x3 b1 = uint3x3(1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228);
+            uint3x3 r1 = uint3x3(1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x3 a2 = uint3x3(1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074, 543305337, 662107399, 1934997335);
+            uint3x3 b2 = uint3x3(188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841, 108816721, 1694053551, 452638547);
+            uint3x3 r2 = uint3x3(2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171, 645820281, 1744827823, 2080356183);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x3 a3 = uint3x3(436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            uint3x3 b3 = uint3x3(1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            uint3x3 r3 = uint3x3(1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_or_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789);
+            uint b0 = (1666102508);
+            uint3x3 r0 = uint3x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x3 a1 = uint3x3(1637162093, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989, 1980838747, 284225881);
+            uint b1 = (1227888278);
+            uint3x3 r1 = uint3x3(1773477631, 1865602742, 2105089982, 1333229279, 1874132982, 2112886719, 1274806167, 2133931999, 1508964319);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x3 a2 = uint3x3(64304104, 1393862490, 1890090886, 521303722, 2021379070, 2055963359, 1511253082, 1775629833, 1142751163);
+            uint b2 = (313591807);
+            uint3x3 r2 = uint3x3(334837759, 1404413951, 1924759551, 531855359, 2063323135, 2059110399, 1521739775, 2079717375, 1455292415);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x3 a3 = uint3x3(1767274359, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200, 1353013374);
+            uint b3 = (1421981808);
+            uint3x3 r3 = uint3x3(2111307639, 1576794359, 1559755519, 1961475324, 1455931127, 2096496501, 1607466226, 1440595320, 1424357502);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint3x3 b0 = uint3x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710);
+            uint3x3 r0 = uint3x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (1348323481);
+            uint3x3 b1 = uint3x3(1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473, 447949225, 527022375);
+            uint3x3 r1 = uint3x3(1409150395, 2044710617, 2138963197, 1971321503, 1493170683, 1425918105, 1499453881, 1526720953, 1602091455);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (1947148461);
+            uint3x3 b2 = uint3x3(305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808, 2052547661, 582843231);
+            uint3x3 r2 = uint3x3(1983898861, 2127540973, 2088725757, 2129601277, 2124393197, 1961878511, 1976547565, 2120180973, 1992260607);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (656983670);
+            uint3x3 b3 = uint3x3(1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598, 1098359242);
+            uint3x3 r3 = uint3x3(2012151678, 1736044278, 931000318, 1060691710, 666879990, 1877598071, 800640759, 2139019006, 1736435710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_xor_wide_wide()
+        {
+            uint3x3 a0 = uint3x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340);
+            uint3x3 b0 = uint3x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711);
+            uint3x3 r0 = uint3x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x3 a1 = uint3x3(643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472);
+            uint3x3 b1 = uint3x3(1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157);
+            uint3x3 r1 = uint3x3(1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x3 a2 = uint3x3(314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405, 1972524935, 91962333, 1960780785);
+            uint3x3 b2 = uint3x3(1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483, 1340735463, 546583617, 1034420616);
+            uint3x3 r2 = uint3x3(1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070, 981182560, 636424092, 1232544377);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x3 a3 = uint3x3(1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            uint3x3 b3 = uint3x3(262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            uint3x3 r3 = uint3x3(1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_xor_wide_scalar()
+        {
+            uint3x3 a0 = uint3x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431);
+            uint b0 = (493665894);
+            uint3x3 r0 = uint3x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x3 a1 = uint3x3(353786540, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978, 491079274, 191750702);
+            uint b1 = (1308626970);
+            uint3x3 r1 = uint3x3(1528187574, 93328233, 1232959970, 6998720, 689905479, 1224162372, 1483050112, 1397053040, 1164833332);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x3 a2 = uint3x3(187129429, 549951551, 653124416, 788984, 1479174924, 1680011736, 447453839, 890841598, 293394300);
+            uint b2 = (967051293);
+            uint3x3 r2 = uint3x3(847468104, 425955362, 524938077, 967311845, 1636721425, 1569126853, 588223122, 213721571, 685301601);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x3 a3 = uint3x3(527727631, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239, 476052372);
+            uint b3 = (529042816);
+            uint3x3 r3 = uint3x3(16576911, 1307134418, 1483505245, 548297055, 871053291, 475694844, 1940126849, 528638031, 64452116);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint3x3 b0 = uint3x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217);
+            uint3x3 r0 = uint3x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1509843030);
+            uint3x3 b1 = uint3x3(1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099);
+            uint3x3 r1 = uint3x3(505195842, 489209886, 769935181, 809406758, 704722596, 430263842, 1219290719, 194675349, 1845940413);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1309568053);
+            uint3x3 b2 = uint3x3(221134131, 885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520, 86594349, 2006985393);
+            uint3x3 r2 = uint3x3(1126191366, 2059580163, 1786054505, 1168069184, 491622028, 1816020124, 571655301, 1260863256, 967722628);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1431761813);
+            uint3x3 b3 = uint3x3(905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615, 711527976);
+            uint3x3 r3 = uint3x3(1622008160, 266913576, 1579801450, 2144176381, 1125708626, 1502456780, 143731639, 2065991874, 2134900157);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_left_shift()
+        {
+            uint3x3 a0 = uint3x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230);
+            int b0 = (1321149625);
+            uint3x3 r0 = uint3x3(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832, 2885681152);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint3x3 a1 = uint3x3(1531607705, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989, 2077023268, 592678686);
+            int b1 = (1360008038);
+            uint3x3 r1 = uint3x3(3533612608, 106468736, 2458634112, 375843008, 2282709952, 3445879680, 2069060416, 4080470272, 3571697536);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint3x3 a2 = uint3x3(297755411, 1161625759, 37265945, 997793693, 1521705181, 263886278, 221147365, 2084190583, 230910816);
+            int b2 = (1722762487);
+            uint3x3 r2 = uint3x3(2306867200, 1333788672, 209715200, 3464495104, 1853882368, 3808428032, 1920991232, 3145728000, 2952790016);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint3x3 a3 = uint3x3(71403448, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192, 740058147);
+            int b3 = (481375728);
+            uint3x3 r3 = uint3x3(2276982784, 3986685952, 1071316992, 705495040, 1989148672, 1981153280, 2880831488, 1022361600, 1680015360);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_right_shift()
+        {
+            uint3x3 a0 = uint3x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124);
+            int b0 = (1266801540);
+            uint3x3 r0 = uint3x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint3x3 a1 = uint3x3(506619530, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711, 334005460, 1624751550);
+            int b1 = (426807581);
+            uint3x3 r1 = uint3x3(0, 3, 1, 1, 1, 0, 2, 0, 3);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint3x3 a2 = uint3x3(280138733, 1840564178, 736389149, 1279158873, 408822762, 763607760, 348013684, 1568185874, 774126687);
+            int b2 = (1598620011);
+            uint3x3 r2 = uint3x3(136786, 898712, 359565, 624589, 199620, 372855, 169928, 765715, 377991);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint3x3 a3 = uint3x3(1587054000, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381, 1234295294);
+            int b3 = (600069797);
+            uint3x3 r3 = uint3x3(49595437, 924264, 58780668, 11005463, 36390889, 13295044, 5829453, 34370605, 38571727);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x3_operator_bitwise_not()
+        {
+            uint3x3 a0 = uint3x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491);
+            uint3x3 r0 = uint3x3(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439, 3822001804);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint3x3 a1 = uint3x3(771711426, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466, 1635981125, 1951018596);
+            uint3x3 r1 = uint3x3(3523255869, 2233443271, 3541758807, 2197788012, 2991944802, 3630222692, 3005594829, 2658986170, 2343948699);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint3x3 a2 = uint3x3(1545651937, 1284504687, 1342785385, 869629475, 2045854321, 1282546942, 1562433528, 1824824810, 1736570715);
+            uint3x3 r2 = uint3x3(2749315358, 3010462608, 2952181910, 3425337820, 2249112974, 3012420353, 2732533767, 2470142485, 2558396580);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint3x3 a3 = uint3x3(508906058, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829, 1227946838);
+            uint3x3 r3 = uint3x3(3786061237, 2427548539, 3906437021, 3599787443, 2528029256, 3397043669, 2478776831, 2932060466, 3067020457);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..2d909545c64536f8f2a40b47c308978a9b4b2e31
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f3db3407f5e21b84d8c21645d5517e9b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..bb13e12b66d6aa65004d6dc7dad6203adf96e04b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs
@@ -0,0 +1,1233 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint3x4
+    {
+        [TestCompiler]
+        public static void uint3x4_zero()
+        {
+            TestUtils.AreEqual(uint3x4.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c1.z, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c2.y, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c2.z, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c3.x, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c3.y, 0u);
+            TestUtils.AreEqual(uint3x4.zero.c3.z, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_equal_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            uint3x4 b0 = uint3x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x4 a1 = uint3x4(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint3x4 b1 = uint3x4(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x4 a2 = uint3x4(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            uint3x4 b2 = uint3x4(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x4 a3 = uint3x4(346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            uint3x4 b3 = uint3x4(1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_equal_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411);
+            uint b0 = (746972502);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint3x4 a1 = uint3x4(672785749, 585324157, 404448210, 969511077, 442746747, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005);
+            uint b1 = (1465584610);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint3x4 a2 = uint3x4(211986678, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291);
+            uint b2 = (1305479811);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint3x4 a3 = uint3x4(872759249, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886, 20195989);
+            uint b3 = (811880239);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint3x4 b0 = uint3x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064);
+            bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (737210539);
+            uint3x4 b1 = uint3x4(1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832);
+            bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (597498209);
+            uint3x4 b2 = uint3x4(367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415);
+            bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1576985758);
+            uint3x4 b3 = uint3x4(1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036, 2074160001);
+            bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_not_equal_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            uint3x4 b0 = uint3x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x4 a1 = uint3x4(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint3x4 b1 = uint3x4(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x4 a2 = uint3x4(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            uint3x4 b2 = uint3x4(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x4 a3 = uint3x4(1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            uint3x4 b3 = uint3x4(1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_not_equal_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906);
+            uint b0 = (248693828);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint3x4 a1 = uint3x4(2126300423, 2035077187, 1171827730, 1412347883, 1622176923, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766);
+            uint b1 = (791998981);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint3x4 a2 = uint3x4(30493685, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113);
+            uint b2 = (904014575);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint3x4 a3 = uint3x4(765258490, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942, 780105497);
+            uint b3 = (668154629);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint3x4 b0 = uint3x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (50286949);
+            uint3x4 b1 = uint3x4(2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720);
+            bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (510966350);
+            uint3x4 b2 = uint3x4(572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (358894860);
+            uint3x4 b3 = uint3x4(1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167, 1002934795);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            uint3x4 b0 = uint3x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool3x4 r0 = bool3x4(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x4 a1 = uint3x4(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint3x4 b1 = uint3x4(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x4 a2 = uint3x4(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            uint3x4 b2 = uint3x4(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool3x4 r2 = bool3x4(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x4 a3 = uint3x4(1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            uint3x4 b3 = uint3x4(1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool3x4 r3 = bool3x4(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650);
+            uint b0 = (1491216667);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint3x4 a1 = uint3x4(930950514, 933855388, 908563901, 1127696709, 1286331950, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027);
+            uint b1 = (1100560246);
+            bool3x4 r1 = bool3x4(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint3x4 a2 = uint3x4(371987110, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606);
+            uint b2 = (867559111);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint3x4 a3 = uint3x4(1891059504, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493, 212954934);
+            uint b3 = (1217893177);
+            bool3x4 r3 = bool3x4(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint3x4 b0 = uint3x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311);
+            bool3x4 r0 = bool3x4(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1890019295);
+            uint3x4 b1 = uint3x4(2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659);
+            bool3x4 r1 = bool3x4(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (810406400);
+            uint3x4 b2 = uint3x4(1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916);
+            bool3x4 r2 = bool3x4(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (168788814);
+            uint3x4 b3 = uint3x4(670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033, 685700324);
+            bool3x4 r3 = bool3x4(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            uint3x4 b0 = uint3x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool3x4 r0 = bool3x4(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x4 a1 = uint3x4(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint3x4 b1 = uint3x4(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x4 a2 = uint3x4(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            uint3x4 b2 = uint3x4(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool3x4 r2 = bool3x4(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x4 a3 = uint3x4(194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            uint3x4 b3 = uint3x4(1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515);
+            uint b0 = (438688675);
+            bool3x4 r0 = bool3x4(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint3x4 a1 = uint3x4(711945018, 577943770, 572743717, 1016617211, 2063134811, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424);
+            uint b1 = (1035679270);
+            bool3x4 r1 = bool3x4(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint3x4 a2 = uint3x4(1045140419, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732);
+            uint b2 = (1058332184);
+            bool3x4 r2 = bool3x4(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint3x4 a3 = uint3x4(1284938191, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269, 1930086291);
+            uint b3 = (1452639553);
+            bool3x4 r3 = bool3x4(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint3x4 b0 = uint3x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204);
+            bool3x4 r0 = bool3x4(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1556466996);
+            uint3x4 b1 = uint3x4(858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711);
+            bool3x4 r1 = bool3x4(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1713088900);
+            uint3x4 b2 = uint3x4(315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261);
+            bool3x4 r2 = bool3x4(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (267985383);
+            uint3x4 b3 = uint3x4(126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217, 1480829811);
+            bool3x4 r3 = bool3x4(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_equal_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            uint3x4 b0 = uint3x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool3x4 r0 = bool3x4(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x4 a1 = uint3x4(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint3x4 b1 = uint3x4(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool3x4 r1 = bool3x4(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x4 a2 = uint3x4(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            uint3x4 b2 = uint3x4(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool3x4 r2 = bool3x4(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x4 a3 = uint3x4(1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            uint3x4 b3 = uint3x4(1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_equal_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763);
+            uint b0 = (1688048545);
+            bool3x4 r0 = bool3x4(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint3x4 a1 = uint3x4(690091301, 2091514001, 1857173043, 1617221948, 2017733017, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519);
+            uint b1 = (1806172431);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint3x4 a2 = uint3x4(1917813750, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244);
+            uint b2 = (1258115260);
+            bool3x4 r2 = bool3x4(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint3x4 a3 = uint3x4(426908235, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266, 1483727269);
+            uint b3 = (1818566980);
+            bool3x4 r3 = bool3x4(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint3x4 b0 = uint3x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1293698493);
+            uint3x4 b1 = uint3x4(48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566);
+            bool3x4 r1 = bool3x4(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (601413850);
+            uint3x4 b2 = uint3x4(830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260);
+            bool3x4 r2 = bool3x4(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (733876180);
+            uint3x4 b3 = uint3x4(1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410, 1987696011);
+            bool3x4 r3 = bool3x4(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_equal_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            uint3x4 b0 = uint3x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool3x4 r0 = bool3x4(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x4 a1 = uint3x4(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint3x4 b1 = uint3x4(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool3x4 r1 = bool3x4(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x4 a2 = uint3x4(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            uint3x4 b2 = uint3x4(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool3x4 r2 = bool3x4(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x4 a3 = uint3x4(584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            uint3x4 b3 = uint3x4(2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_equal_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867);
+            uint b0 = (1470533736);
+            bool3x4 r0 = bool3x4(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint3x4 a1 = uint3x4(1419295004, 1819986195, 1460027917, 1646290021, 196833647, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862);
+            uint b1 = (471843809);
+            bool3x4 r1 = bool3x4(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint3x4 a2 = uint3x4(1449142607, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895);
+            uint b2 = (1223010129);
+            bool3x4 r2 = bool3x4(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint3x4 a3 = uint3x4(192092521, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700, 702382564);
+            uint b3 = (909358617);
+            bool3x4 r3 = bool3x4(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint3x4 b0 = uint3x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637);
+            bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (1214546726);
+            uint3x4 b1 = uint3x4(917376832, 303549425, 2111728811, 945321577, 173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189);
+            bool3x4 r1 = bool3x4(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (1336522452);
+            uint3x4 b2 = uint3x4(233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513);
+            bool3x4 r2 = bool3x4(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (474197678);
+            uint3x4 b3 = uint3x4(1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168, 1274079907);
+            bool3x4 r3 = bool3x4(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_add_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            uint3x4 b0 = uint3x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            uint3x4 r0 = uint3x4(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161, 2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x4 a1 = uint3x4(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint3x4 b1 = uint3x4(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint3x4 r1 = uint3x4(4147356693, 749502583, 623052937, 3113339623, 2178242226, 3146426160, 1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x4 a2 = uint3x4(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            uint3x4 b2 = uint3x4(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            uint3x4 r2 = uint3x4(3048865720, 2901392143, 1940611170, 1099044556, 2362767916, 1285092016, 2641863205, 3757383291, 604086579, 2150755997, 3626413591, 2674116169);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x4 a3 = uint3x4(728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            uint3x4 b3 = uint3x4(1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            uint3x4 r3 = uint3x4(2461211795, 1450246522, 2444787499, 1669976746, 3356749404, 1917402232, 1548618217, 2863380484, 3471071068, 2013864506, 348877644, 2242427741);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_add_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202);
+            uint b0 = (2124409227);
+            uint3x4 r0 = uint3x4(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528, 4127431088, 3760381198, 3284807513, 2209855429);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint3x4 a1 = uint3x4(1068152966, 1497676888, 1727477485, 1095438654, 756559204, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233);
+            uint b1 = (1239387100);
+            uint3x4 r1 = uint3x4(2307540066, 2737063988, 2966864585, 2334825754, 1995946304, 3058106031, 1898310652, 2849906021, 2825142498, 1932230400, 2307980569, 2944163333);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint3x4 a2 = uint3x4(577782260, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190);
+            uint b2 = (736972565);
+            uint3x4 r2 = uint3x4(1314754825, 1448867136, 1301230004, 2788708848, 2309810262, 2364979110, 2592672828, 1393721347, 1009747081, 2654105764, 1565295538, 2853782755);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint3x4 a3 = uint3x4(2092767444, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914, 1340503111);
+            uint b3 = (973587865);
+            uint3x4 r3 = uint3x4(3066355309, 2210519138, 1477852314, 1767880439, 2491646546, 2578224189, 1328461282, 1658835762, 1201369005, 1294770382, 2184163779, 2314090976);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint3x4 b0 = uint3x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302);
+            uint3x4 r0 = uint3x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150, 1387123903, 1948867027, 1170867018, 1502633380);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (783046445);
+            uint3x4 b1 = uint3x4(1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768);
+            uint3x4 r1 = uint3x4(1913210389, 1071326029, 2180730306, 2419629934, 1456309784, 2252347319, 797902410, 1899683444, 2271909745, 2384037331, 973697746, 2090506213);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (920085839);
+            uint3x4 b2 = uint3x4(2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886);
+            uint3x4 r2 = uint3x4(3002315674, 2912491413, 2134010297, 1425927291, 1901507001, 2408423538, 2033912479, 2726232347, 2761877061, 1126696690, 1447057792, 2156445725);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1459523189);
+            uint3x4 b3 = uint3x4(965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031, 1275565021);
+            uint3x4 r3 = uint3x4(2425263820, 1542365988, 2757926390, 3265332961, 3438387380, 1874526575, 3365827337, 2182393386, 2203771985, 3136746748, 1762899220, 2735088210);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_sub_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            uint3x4 b0 = uint3x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            uint3x4 r0 = uint3x4(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549, 1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x4 a1 = uint3x4(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint3x4 b1 = uint3x4(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint3x4 r1 = uint3x4(4244761393, 3364773944, 120810088, 929308315, 3670565287, 4129068219, 3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x4 a2 = uint3x4(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            uint3x4 b2 = uint3x4(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            uint3x4 r2 = uint3x4(4111227161, 972642792, 3745373142, 2826807304, 3564332942, 1218011798, 1846728662, 3739059778, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x4 a3 = uint3x4(741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            uint3x4 b3 = uint3x4(1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            uint3x4 r3 = uint3x4(3949049757, 1650323877, 979082147, 182559134, 4158572232, 1442113917, 8339009, 1379854326, 3702505823, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_sub_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336);
+            uint b0 = (462232403);
+            uint3x4 r0 = uint3x4(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412, 4113909093, 3920265733, 1451492028, 1579360933);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint3x4 a1 = uint3x4(557239990, 1590376732, 819090189, 816382635, 815920639, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742);
+            uint b1 = (1119051448);
+            uint3x4 r1 = uint3x4(3733155838, 471325284, 3995006037, 3992298483, 3991836487, 709981669, 673750484, 4289356397, 299886528, 158205741, 973727950, 3818152590);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint3x4 a2 = uint3x4(1605250794, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204);
+            uint b2 = (819644478);
+            uint3x4 r2 = uint3x4(785606316, 648358541, 3603626004, 4028817075, 197482493, 1180100304, 1197628280, 998347286, 461341022, 4152297673, 818388135, 130116726);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint3x4 a3 = uint3x4(1835969317, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965, 941598524);
+            uint b3 = (919015590);
+            uint3x4 r3 = uint3x4(916953727, 57931720, 385231016, 537764618, 635007122, 4145756071, 1138816097, 4134088285, 4046384961, 3979183117, 754253375, 22582934);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint3x4 b0 = uint3x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748);
+            uint3x4 r0 = uint3x4(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128, 4197201280, 1426821512, 459678338, 4168388953);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (1428436109);
+            uint3x4 b1 = uint3x4(1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461);
+            uint3x4 r1 = uint3x4(169690649, 351055713, 97713390, 910324280, 461307580, 1083769855, 346168191, 520569413, 3906518282, 968095541, 466281611, 871322648);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (1701216709);
+            uint3x4 b2 = uint3x4(1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026);
+            uint3x4 r2 = uint3x4(4016085228, 971156157, 256818882, 847646153, 1562380277, 688026281, 983127179, 1194459319, 484768668, 764903962, 3998897550, 4026201979);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (902880656);
+            uint3x4 b3 = uint3x4(1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072, 2066839749);
+            uint3x4 r3 = uint3x4(4036627255, 3755383227, 279919891, 171911747, 288056815, 3308068932, 4279525600, 768950736, 689757548, 3362397492, 381812584, 3131008203);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mul_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            uint3x4 b0 = uint3x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            uint3x4 r0 = uint3x4(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228, 2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x4 a1 = uint3x4(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint3x4 b1 = uint3x4(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint3x4 r1 = uint3x4(990589280, 3356793344, 2953243830, 1156600361, 649177976, 678952165, 1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x4 a2 = uint3x4(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            uint3x4 b2 = uint3x4(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            uint3x4 r2 = uint3x4(1891467339, 335415735, 1128927428, 2638713520, 2861115658, 479369680, 3928339236, 4044803354, 48406862, 2297104000, 4019846068, 2811510105);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x4 a3 = uint3x4(892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            uint3x4 b3 = uint3x4(142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            uint3x4 r3 = uint3x4(293009766, 3677102970, 1179445736, 3813187164, 2708838392, 1397450915, 487571412, 3889286542, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mul_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747);
+            uint b0 = (1476837906);
+            uint3x4 r0 = uint3x4(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778, 1736252960, 2595843622, 2760103458, 2441439286);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint3x4 a1 = uint3x4(1818877398, 660611671, 1279757657, 391009467, 1186856590, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300);
+            uint b1 = (1324050764);
+            uint3x4 r1 = uint3x4(1927061896, 645718228, 3706353516, 3450526340, 3727282216, 2610351864, 3202713768, 133057916, 2712818352, 3265005844, 4046133608, 100822256);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint3x4 a2 = uint3x4(1192501703, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648);
+            uint b2 = (1613845584);
+            uint3x4 r2 = uint3x4(3900103216, 2959506480, 692371456, 973833232, 1630959136, 2616598816, 4103626336, 1516495024, 2027781488, 471196848, 2169531488, 1043640960);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint3x4 a3 = uint3x4(227492421, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790, 396984449);
+            uint b3 = (217698851);
+            uint3x4 r3 = uint3x4(269461871, 1120555251, 1293383984, 1838219542, 3023271884, 1677010101, 1900394426, 512258290, 4056397088, 3786096410, 1697920914, 1359963043);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint3x4 b0 = uint3x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767);
+            uint3x4 r0 = uint3x4(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328, 1623617844, 2603413056, 3464455056, 3011267876);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (243286231);
+            uint3x4 b1 = uint3x4(1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639);
+            uint3x4 r1 = uint3x4(3646578061, 2731337857, 3893490496, 2980416695, 62369507, 4218409817, 2881159196, 3966864259, 2038656731, 2224055319, 2818606435, 2745388689);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1323243330);
+            uint3x4 b2 = uint3x4(1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263);
+            uint3x4 r2 = uint3x4(4200942488, 50866050, 1979584376, 2165828294, 2084048518, 3664351394, 1987582754, 2187955092, 3020934930, 1909741994, 2131645412, 527678350);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (2022856151);
+            uint3x4 b3 = uint3x4(1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370, 890235481);
+            uint3x4 r3 = uint3x4(2359761627, 3607975719, 2368172860, 3241673466, 3640972603, 2445305544, 1198448575, 3108682444, 2733658999, 2364617365, 3384645854, 938433983);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_div_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            uint3x4 b0 = uint3x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            uint3x4 r0 = uint3x4(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x4 a1 = uint3x4(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint3x4 b1 = uint3x4(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint3x4 r1 = uint3x4(0, 2, 1, 2, 1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x4 a2 = uint3x4(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            uint3x4 b2 = uint3x4(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            uint3x4 r2 = uint3x4(2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x4 a3 = uint3x4(991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            uint3x4 b3 = uint3x4(554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            uint3x4 r3 = uint3x4(1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_div_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657);
+            uint b0 = (947861580);
+            uint3x4 r0 = uint3x4(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint3x4 a1 = uint3x4(2131487088, 1017891310, 542666029, 1646044372, 1447236569, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885);
+            uint b1 = (2105094094);
+            uint3x4 r1 = uint3x4(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint3x4 a2 = uint3x4(1919705924, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918);
+            uint b2 = (1244966864);
+            uint3x4 r2 = uint3x4(1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint3x4 a3 = uint3x4(1515555001, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647, 1222061694);
+            uint b3 = (614923813);
+            uint3x4 r3 = uint3x4(2, 1, 3, 3, 3, 1, 3, 0, 0, 2, 3, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint3x4 b0 = uint3x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703);
+            uint3x4 r0 = uint3x4(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (631027637);
+            uint3x4 b1 = uint3x4(396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043);
+            uint3x4 r1 = uint3x4(1, 0, 0, 0, 0, 2, 12, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1054404890);
+            uint3x4 b2 = uint3x4(351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534);
+            uint3x4 r2 = uint3x4(2, 7, 0, 2, 0, 4, 0, 0, 0, 23, 0, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (126616016);
+            uint3x4 b3 = uint3x4(1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719, 638134699);
+            uint3x4 r3 = uint3x4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mod_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            uint3x4 b0 = uint3x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            uint3x4 r0 = uint3x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x4 a1 = uint3x4(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint3x4 b1 = uint3x4(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint3x4 r1 = uint3x4(137194997, 593433700, 360454892, 8060301, 7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x4 a2 = uint3x4(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            uint3x4 b2 = uint3x4(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            uint3x4 r2 = uint3x4(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x4 a3 = uint3x4(1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            uint3x4 b3 = uint3x4(244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            uint3x4 r3 = uint3x4(166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mod_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935);
+            uint b0 = (883951171);
+            uint3x4 r0 = uint3x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint3x4 a1 = uint3x4(712321026, 1540068445, 1085897743, 1607489717, 165478511, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912);
+            uint b1 = (172564850);
+            uint3x4 r1 = uint3x4(22061626, 159549645, 50508643, 54406067, 165478511, 130152166, 52883749, 49746751, 65367033, 49545706, 143379989, 17042712);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint3x4 a2 = uint3x4(377501313, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372);
+            uint b2 = (1778384846);
+            uint3x4 r2 = uint3x4(377501313, 1216011754, 812183417, 1153802502, 1642671870, 146325896, 665297470, 1568090825, 272598096, 435886407, 453990946, 1731665372);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint3x4 a3 = uint3x4(586777590, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411, 1524342239);
+            uint b3 = (1475597526);
+            uint3x4 r3 = uint3x4(586777590, 110051989, 1414579860, 416067455, 1262495021, 1400758118, 53934482, 430295164, 1386414018, 654749032, 666621411, 48744713);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint3x4 b0 = uint3x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233);
+            uint3x4 r0 = uint3x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1298102643);
+            uint3x4 b1 = uint3x4(2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738);
+            uint3x4 r1 = uint3x4(1298102643, 297360552, 1298102643, 1298102643, 500917956, 476213801, 214909646, 457987657, 1298102643, 67782715, 1298102643, 1739061);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (2122220318);
+            uint3x4 b2 = uint3x4(164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894);
+            uint3x4 r2 = uint3x4(147283586, 662044080, 677274179, 816428281, 1011391307, 376773156, 120051662, 644373900, 76505386, 479992776, 159909553, 50931378);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1342085447);
+            uint3x4 b3 = uint3x4(448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751, 1648646354);
+            uint3x4 r3 = uint3x4(445362875, 3415371, 636619696, 588996674, 195741437, 241524871, 267605306, 1342085447, 1342085447, 1342085447, 243643696, 1342085447);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_plus()
+        {
+            uint3x4 a0 = uint3x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            uint3x4 r0 = uint3x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint3x4 a1 = uint3x4(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            uint3x4 r1 = uint3x4(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint3x4 a2 = uint3x4(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            uint3x4 r2 = uint3x4(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint3x4 a3 = uint3x4(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            uint3x4 r3 = uint3x4(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_neg()
+        {
+            uint3x4 a0 = uint3x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286);
+            uint3x4 r0 = uint3x4(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947, 3179939058, 2658692327, 3599972203, 2752761010);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint3x4 a1 = uint3x4(213087293, 341522275, 841085242, 574159094, 1687250035, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864);
+            uint3x4 r1 = uint3x4(4081880003, 3953445021, 3453882054, 3720808202, 2607717261, 2237047603, 3119952564, 3035158223, 3082501970, 3104397376, 2247011524, 2174237432);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint3x4 a2 = uint3x4(1440774928, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868);
+            uint3x4 r2 = uint3x4(2854192368, 3863301205, 2907365578, 2549315298, 3975851670, 3175007490, 3555835012, 2340793982, 2585110198, 2458456246, 2632160843, 3788822428);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint3x4 a3 = uint3x4(650922971, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551, 1768435578);
+            uint3x4 r3 = uint3x4(3644044325, 3020970047, 2820522109, 2441140349, 2599393523, 3565514784, 3949897936, 3719099760, 3700848258, 3093126687, 2952094745, 2526531718);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_prefix_inc()
+        {
+            uint3x4 a0 = uint3x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935);
+            uint3x4 r0 = uint3x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint3x4 a1 = uint3x4(1835605516, 388229350, 696475402, 1786514683, 993189311, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489);
+            uint3x4 r1 = uint3x4(1835605517, 388229351, 696475403, 1786514684, 993189312, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint3x4 a2 = uint3x4(504806865, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111);
+            uint3x4 r2 = uint3x4(504806866, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint3x4 a3 = uint3x4(1414867743, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802, 413165245);
+            uint3x4 r3 = uint3x4(1414867744, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803, 413165246);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_postfix_inc()
+        {
+            uint3x4 a0 = uint3x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            uint3x4 r0 = uint3x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint3x4 a1 = uint3x4(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            uint3x4 r1 = uint3x4(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint3x4 a2 = uint3x4(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            uint3x4 r2 = uint3x4(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint3x4 a3 = uint3x4(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            uint3x4 r3 = uint3x4(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_prefix_dec()
+        {
+            uint3x4 a0 = uint3x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358);
+            uint3x4 r0 = uint3x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint3x4 a1 = uint3x4(1914114460, 389120307, 1022184392, 1310293956, 356565557, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297);
+            uint3x4 r1 = uint3x4(1914114459, 389120306, 1022184391, 1310293955, 356565556, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint3x4 a2 = uint3x4(220897829, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380);
+            uint3x4 r2 = uint3x4(220897828, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint3x4 a3 = uint3x4(2083512379, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317, 767990877);
+            uint3x4 r3 = uint3x4(2083512378, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316, 767990876);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_postfix_dec()
+        {
+            uint3x4 a0 = uint3x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            uint3x4 r0 = uint3x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint3x4 a1 = uint3x4(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            uint3x4 r1 = uint3x4(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint3x4 a2 = uint3x4(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            uint3x4 r2 = uint3x4(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint3x4 a3 = uint3x4(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            uint3x4 r3 = uint3x4(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_and_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            uint3x4 b0 = uint3x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            uint3x4 r0 = uint3x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x4 a1 = uint3x4(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint3x4 b1 = uint3x4(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint3x4 r1 = uint3x4(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x4 a2 = uint3x4(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            uint3x4 b2 = uint3x4(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            uint3x4 r2 = uint3x4(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x4 a3 = uint3x4(1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            uint3x4 b3 = uint3x4(1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            uint3x4 r3 = uint3x4(706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_and_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920);
+            uint b0 = (93423598);
+            uint3x4 r0 = uint3x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint3x4 a1 = uint3x4(1249238550, 1862276471, 143502472, 861733033, 1408932942, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025);
+            uint b1 = (814629680);
+            uint3x4 r1 = uint3x4(279056, 536871216, 9175040, 806092832, 277479424, 805568528, 268452112, 9175824, 268567088, 268697600, 934144, 8650784);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint3x4 a2 = uint3x4(462670926, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061);
+            uint b2 = (1817145060);
+            uint3x4 r2 = uint3x4(134433860, 1145858724, 1816224836, 542076516, 739126372, 1611530816, 537593028, 604439716, 1140983364, 672014980, 1745571424, 1208165380);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint3x4 a3 = uint3x4(398141788, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172, 1826788967);
+            uint b3 = (156911041);
+            uint3x4 r3 = uint3x4(18481472, 17843457, 5783937, 156763393, 22151233, 138937729, 152585345, 4867329, 21643264, 132544, 4719616, 138544193);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint3x4 b0 = uint3x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596);
+            uint3x4 r0 = uint3x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1763483957);
+            uint3x4 b1 = uint3x4(1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366);
+            uint3x4 r1 = uint3x4(1209041205, 136061185, 151265585, 1074528516, 1744830512, 671121697, 1092091952, 1761607941, 18391060, 1761615904, 1763221553, 1091051540);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1233066417);
+            uint3x4 b2 = uint3x4(1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007);
+            uint3x4 r2 = uint3x4(1214058640, 2230321, 1210847617, 1074401680, 1211367456, 1116577, 1232603553, 3674113, 1078202400, 136118672, 1098518961, 4128897);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1808619374);
+            uint3x4 b3 = uint3x4(1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681, 1980296380);
+            uint3x4 r3 = uint3x4(1246058336, 1644778764, 12650346, 1640318254, 1216610624, 587220044, 1644695918, 33834028, 734795298, 671961678, 1241777216, 1644708908);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_or_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            uint3x4 b0 = uint3x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            uint3x4 r0 = uint3x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x4 a1 = uint3x4(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint3x4 b1 = uint3x4(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint3x4 r1 = uint3x4(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x4 a2 = uint3x4(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            uint3x4 b2 = uint3x4(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            uint3x4 r2 = uint3x4(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x4 a3 = uint3x4(470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            uint3x4 b3 = uint3x4(1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            uint3x4 r3 = uint3x4(1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_or_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856);
+            uint b0 = (1666102508);
+            uint3x4 r0 = uint3x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint3x4 a1 = uint3x4(879300408, 797240690, 1977614655, 46921989, 1980838747, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070);
+            uint b1 = (1179087439);
+            uint3x4 r1 = uint3x4(1987018623, 1875378047, 2011657087, 1188035407, 1985442655, 1459090271, 1205302255, 1459058687, 1465382751, 1995407311, 1599567599, 2122316799);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint3x4 a2 = uint3x4(2055963359, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200);
+            uint b2 = (1511253082);
+            uint3x4 r2 = uint3x4(2057037535, 2077750875, 1579155451, 2069362559, 1590951034, 1534850271, 1593306847, 2050745566, 1519910623, 2117597023, 1604316378, 1600120154);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint3x4 a3 = uint3x4(1353013374, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643, 142082352);
+            uint b3 = (1349149982);
+            uint3x4 r3 = uint3x4(1357872510, 1895528286, 1374318015, 2012964638, 1550483390, 1602123263, 1483666815, 1920624063, 1458464191, 2012116286, 1424685023, 1484416318);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint3x4 b0 = uint3x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649);
+            uint3x4 r0 = uint3x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (1059093741);
+            uint3x4 b1 = uint3x4(627815046, 418822515, 83214352, 424663473, 447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329);
+            uint3x4 r1 = uint3x4(1064042223, 1073151487, 1073085693, 1064304125, 1068727789, 1063910895, 2133818605, 1060240621, 2145910509, 2138209533, 2146074365, 2142830317);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (1088734150);
+            uint3x4 b2 = uint3x4(298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598);
+            uint3x4 r2 = uint3x4(1374682086, 2063067087, 1660812255, 1743570934, 1945042926, 1089859558, 1911943150, 2079645678, 1627375606, 1307434967, 1341444039, 1526649806);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (1098359242);
+            uint3x4 b3 = uint3x4(997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616, 1326199854);
+            uint3x4 r3 = uint3x4(2071978954, 1098885598, 2071455727, 1702356954, 1098381823, 1568651246, 2046802926, 1509946863, 2038414794, 1644161007, 1308081658, 1333769710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_xor_wide_wide()
+        {
+            uint3x4 a0 = uint3x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            uint3x4 b0 = uint3x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            uint3x4 r0 = uint3x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x4 a1 = uint3x4(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint3x4 b1 = uint3x4(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint3x4 r1 = uint3x4(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x4 a2 = uint3x4(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            uint3x4 b2 = uint3x4(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            uint3x4 r2 = uint3x4(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x4 a3 = uint3x4(1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            uint3x4 b3 = uint3x4(1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            uint3x4 r3 = uint3x4(632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_xor_wide_scalar()
+        {
+            uint3x4 a0 = uint3x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267);
+            uint b0 = (493665894);
+            uint3x4 r0 = uint3x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint3x4 a1 = uint3x4(125659640, 1730088797, 116862046, 375757978, 491079274, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924);
+            uint b1 = (1315625690);
+            uint3x4 r1 = uint3x4(1226289954, 695588231, 1218311812, 1477396032, 1395629232, 1158101236, 1162708111, 2010043079, 1856848613, 1753692570, 1315361570, 373338582);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint3x4 a2 = uint3x4(1680011736, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239);
+            uint b2 = (447453839);
+            uint3x4 r2 = uint3x4(2122935127, 800240497, 198659571, 98559616, 86185743, 1221222109, 1565485394, 630017616, 919085284, 427397619, 1988160398, 446789440);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint3x4 a3 = uint3x4(476052372, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185, 1771744425);
+            uint b3 = (92561487);
+            uint3x4 r3 = uint3x4(433822683, 2133436125, 133297725, 1274987888, 2020970994, 180462097, 52620731, 1114759625, 2024733453, 2005017615, 912470822, 1813957862);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint3x4 b0 = uint3x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424);
+            uint3x4 r0 = uint3x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1947871003);
+            uint3x4 b1 = uint3x4(1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881);
+            uint3x4 r1 = uint3x4(500881003, 132477417, 876677487, 1699258642, 645842392, 1138923504, 974408494, 2033457704, 1087830061, 1348553799, 2139822446, 660194722);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (573581481);
+            uint3x4 b2 = uint3x4(1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615);
+            uint3x4 r2 = uint3x4(1311539225, 655981444, 1435501080, 2003229500, 399194716, 2022579220, 693043286, 145445825, 880683118, 787181808, 2146955403, 205673470);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (711527976);
+            uint3x4 b3 = uint3x4(710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645, 896851285);
+            uint3x4 r3 = uint3x4(3284335, 658000982, 154339351, 2085169939, 946304861, 44451568, 2115414221, 2137251591, 317021346, 552683235, 1575100285, 522048381);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_left_shift()
+        {
+            uint3x4 a0 = uint3x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534);
+            int b0 = (1321149625);
+            uint3x4 r0 = uint3x4(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832, 2885681152, 838860800, 3422552064, 2885681152);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint3x4 a1 = uint3x4(1447702302, 35667343, 1664454606, 2045594989, 2077023268, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181);
+            int b1 = (1079614371);
+            uint3x4 r1 = uint3x4(2991683824, 285338744, 430734960, 3479858024, 3731284256, 446462192, 2382043288, 897198008, 703071480, 298127560, 3687382248, 3583706856);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint3x4 a2 = uint3x4(263886278, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192);
+            int b2 = (221147365);
+            uint3x4 r2 = uint3x4(4149393600, 2269589216, 3094178816, 2284910336, 2519121408, 3273503744, 1296563040, 2556772768, 1884213760, 3366896320, 160790208, 31956480);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint3x4 a3 = uint3x4(740058147, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326, 1996060114);
+            int b3 = (946058001);
+            uint3x4 r3 = uint3x4(3360030720, 4207017984, 1441398784, 3029598208, 4289593344, 2718695424, 3680632832, 1110573056, 1163132928, 173408256, 1445724160, 3953393664);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_right_shift()
+        {
+            uint3x4 a0 = uint3x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045);
+            int b0 = (1266801540);
+            uint3x4 r0 = uint3x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint3x4 a1 = uint3x4(701927980, 569504877, 185593382, 1102123711, 334005460, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762);
+            int b1 = (917785020);
+            uint3x4 r1 = uint3x4(2, 2, 0, 4, 1, 6, 1, 5, 6, 2, 4, 1);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint3x4 a2 = uint3x4(763607760, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381);
+            int b2 = (348013684);
+            uint3x4 r2 = uint3x4(728, 1495, 738, 1513, 572, 28, 1793, 335, 1110, 405, 177, 1048);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint3x4 a3 = uint3x4(1234295294, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981, 1435331003);
+            int b3 = (1028666766);
+            uint3x4 r3 = uint3x4(75335, 46488, 76590, 55139, 72040, 11168, 58514, 65650, 86028, 96236, 42779, 87605);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint3x4_operator_bitwise_not()
+        {
+            uint3x4 a0 = uint3x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024);
+            uint3x4 r0 = uint3x4(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439, 3822001804, 3523255869, 3667386335, 2233443271);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint3x4 a1 = uint3x4(753208488, 1303022493, 664744603, 1289372466, 1635981125, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321);
+            uint3x4 r1 = uint3x4(3541758807, 2991944802, 3630222692, 3005594829, 2658986170, 2343948699, 2749315358, 3577030838, 3010462608, 2952181910, 3425337820, 2249112974);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint3x4 a2 = uint3x4(1282546942, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829);
+            uint3x4 r2 = uint3x4(3012420353, 2470142485, 2558396580, 3786061237, 2234214415, 2427548539, 3906437021, 3599787443, 2528029256, 3397043669, 2478776831, 2932060466);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint3x4 a3 = uint3x4(1227946838, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010, 722020848);
+            uint3x4 r3 = uint3x4(3067020457, 4105358017, 3338525487, 2171478485, 2701953044, 4275744234, 2572859341, 2658091601, 2380869903, 2912422268, 3009690285, 3572946447);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..be725d5e220cbad584dca93829ce5dc1095d5a04
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint3x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f4c3a82cd7a932a4a97b7432498a1d53
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..7b5587d68fbb1eb4afe46526cd01e199ad1fd918
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs
@@ -0,0 +1,1353 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint4
+    {
+        [TestCompiler]
+        public static void uint4_zero()
+        {
+            TestUtils.AreEqual(uint4.zero.x, 0u);
+            TestUtils.AreEqual(uint4.zero.y, 0u);
+            TestUtils.AreEqual(uint4.zero.z, 0u);
+            TestUtils.AreEqual(uint4.zero.w, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint4_constructor()
+        {
+            uint4 a = new uint4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void uint4_scalar_constructor()
+        {
+            uint4 a = new uint4(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+            TestUtils.AreEqual(a.z, 17u);
+            TestUtils.AreEqual(a.w, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint4_static_constructor()
+        {
+            uint4 a = uint4(1, 2, 3, 4);
+            TestUtils.AreEqual(a.x, 1);
+            TestUtils.AreEqual(a.y, 2);
+            TestUtils.AreEqual(a.z, 3);
+            TestUtils.AreEqual(a.w, 4);
+        }
+
+        [TestCompiler]
+        public static void uint4_static_scalar_constructor()
+        {
+            uint4 a = uint4(17u);
+            TestUtils.AreEqual(a.x, 17u);
+            TestUtils.AreEqual(a.y, 17u);
+            TestUtils.AreEqual(a.z, 17u);
+            TestUtils.AreEqual(a.w, 17u);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_equal_wide_wide()
+        {
+            uint4 a0 = uint4(790229414, 970783976, 1428432738, 1578747135);
+            uint4 b0 = uint4(612337669, 1214209108, 2120643427, 295461214);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4 a1 = uint4(1733797753, 2001507228, 1446876437, 1777406370);
+            uint4 b1 = uint4(1510890331, 1893316566, 921816149, 1834958575);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4 a2 = uint4(1426387268, 1809275021, 1843770816, 1172185222);
+            uint4 b2 = uint4(1482011863, 2062852792, 226398742, 770290735);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4 a3 = uint4(1469608940, 869874758, 458603090, 581282460);
+            uint4 b3 = uint4(36812057, 543224481, 1565350150, 1909926604);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_equal_wide_scalar()
+        {
+            uint4 a0 = uint4(1211464300, 1921862607, 508076684, 1249127920);
+            uint b0 = (746972502);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4 a1 = uint4(1394594555, 1733655277, 1884008277, 1682018538);
+            uint b1 = (746862310);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4 a2 = uint4(795585660, 927605411, 672785749, 1465584610);
+            uint b2 = (936027116);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4 a3 = uint4(585324157, 969511077, 442746747, 1772925698);
+            uint b3 = (404448210);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint4 b0 = uint4(233855098, 924242519, 1402948791, 601381975);
+            bool4 r0 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (2120518068);
+            uint4 b1 = uint4(629187703, 1971977031, 47183124, 1061805787);
+            bool4 r1 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (1009011238);
+            uint4 b2 = uint4(312511148, 1460673064, 737210539, 1737844479);
+            bool4 r2 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1892405453);
+            uint4 b3 = uint4(2133024000, 455818693, 2003197687, 1276241219);
+            bool4 r3 = bool4(false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_not_equal_wide_wide()
+        {
+            uint4 a0 = uint4(1660932106, 982847023, 97046264, 1739517447);
+            uint4 b0 = uint4(107139049, 75478496, 2055495054, 358586687);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4 a1 = uint4(1253499180, 1830584069, 1841470429, 1397841646);
+            uint4 b1 = uint4(942338347, 111564990, 113811950, 948912488);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4 a2 = uint4(1770890135, 1906548631, 169082967, 2099271786);
+            uint4 b2 = uint4(1080084121, 1400504872, 1032134499, 1061123400);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4 a3 = uint4(1909317609, 46519139, 1433204003, 931492669);
+            uint4 b3 = uint4(221862069, 858950046, 989094643, 2023070999);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_not_equal_wide_scalar()
+        {
+            uint4 a0 = uint4(747758183, 1033001286, 1439973882, 2138928797);
+            uint b0 = (248693828);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4 a1 = uint4(1197845089, 950170763, 238704450, 2105962247);
+            uint b1 = (1432672459);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4 a2 = uint4(727205263, 276313906, 2126300423, 791998981);
+            uint b2 = (1640688041);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4 a3 = uint4(2035077187, 1412347883, 1622176923, 768370497);
+            uint b3 = (1171827730);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint4 b0 = uint4(2037494727, 1989050616, 48833929, 1897435904);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (514354517);
+            uint4 b1 = uint4(1783749164, 364694471, 754315072, 124108032);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (1512967900);
+            uint4 b2 = uint4(1178825850, 1854793298, 50286949, 2100802631);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1640811853);
+            uint4 b3 = uint4(82110247, 472172806, 266984506, 2003668365);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_wide_wide()
+        {
+            uint4 a0 = uint4(1182186063, 415538999, 1667335818, 1566618442);
+            uint4 b0 = uint4(524633529, 1032195686, 760723389, 1505751409);
+            bool4 r0 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4 a1 = uint4(1166180837, 639095188, 1080836365, 771119973);
+            uint4 b1 = uint4(431962172, 1287906509, 1560084663, 1450178202);
+            bool4 r1 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4 a2 = uint4(928263233, 789225474, 665243110, 1003542034);
+            uint4 b2 = uint4(2066166337, 1107069023, 1640077524, 2103263105);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4 a3 = uint4(1032480172, 1961336172, 923379558, 21210619);
+            uint4 b3 = uint4(684229139, 1234033624, 1278743281, 1953079347);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_wide_scalar()
+        {
+            uint4 a0 = uint4(608447185, 818840405, 869219329, 2080125385);
+            uint b0 = (1491216667);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4 a1 = uint4(1214500548, 1667165786, 1615392341, 840091491);
+            uint b1 = (1361741203);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4 a2 = uint4(469591900, 315321650, 930950514, 1100560246);
+            uint b2 = (1247103789);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4 a3 = uint4(933855388, 1127696709, 1286331950, 380753337);
+            uint b3 = (908563901);
+            bool4 r3 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint4 b0 = uint4(282703327, 14370648, 1862117300, 1304793311);
+            bool4 r0 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (826073259);
+            uint4 b1 = uint4(988910157, 445132446, 1139670255, 111349251);
+            bool4 r1 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1102440676);
+            uint4 b2 = uint4(112183144, 1594415311, 1890019295, 2098715503);
+            bool4 r2 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (608933527);
+            uint4 b3 = uint4(183989010, 1596056507, 1027318999, 146281093);
+            bool4 r3 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_wide_wide()
+        {
+            uint4 a0 = uint4(592884447, 2133928932, 918957182, 1284069471);
+            uint4 b0 = uint4(138737040, 192863971, 1700841444, 1044631301);
+            bool4 r0 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4 a1 = uint4(194584707, 739120780, 241654068, 1340158550);
+            uint4 b1 = uint4(1391589821, 730837695, 253553987, 2078872742);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4 a2 = uint4(2099542537, 1182623667, 1399607274, 789301637);
+            uint4 b2 = uint4(910845808, 976047676, 202633078, 1223618940);
+            bool4 r2 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4 a3 = uint4(180400925, 594688333, 1877031463, 1360073500);
+            uint4 b3 = uint4(641600530, 1830470354, 1570701388, 1104256103);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_wide_scalar()
+        {
+            uint4 a0 = uint4(1097138316, 211763648, 1883002501, 56406996);
+            uint b0 = (438688675);
+            bool4 r0 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4 a1 = uint4(43662641, 1437755186, 1219010035, 2125058448);
+            uint b1 = (1923456111);
+            bool4 r1 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4 a2 = uint4(304028799, 48044515, 711945018, 1035679270);
+            uint b2 = (893125636);
+            bool4 r2 = bool4(false, false, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4 a3 = uint4(577943770, 1016617211, 2063134811, 1577403353);
+            uint b3 = (572743717);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint4 b0 = uint4(599356784, 185671342, 1932327391, 2025591013);
+            bool4 r0 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1257191721);
+            uint4 b1 = uint4(1312388500, 1443698859, 779217735, 691047512);
+            bool4 r1 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (741776730);
+            uint4 b2 = uint4(732565983, 668302204, 1556466996, 858599525);
+            bool4 r2 = bool4(true, true, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (1896917159);
+            uint4 b3 = uint4(701542098, 1052151621, 1023307544, 1435392907);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_equal_wide_wide()
+        {
+            uint4 a0 = uint4(1577248162, 2043073061, 1688380407, 176431985);
+            uint4 b0 = uint4(903445031, 2108974565, 210822256, 1281704747);
+            bool4 r0 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4 a1 = uint4(223299035, 1502802140, 1691709825, 386789394);
+            uint4 b1 = uint4(453681718, 66138830, 1229799377, 1620922595);
+            bool4 r1 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4 a2 = uint4(117182003, 1665770435, 1958490731, 420032601);
+            uint4 b2 = uint4(1715833766, 1366430432, 13102000, 46919981);
+            bool4 r2 = bool4(true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4 a3 = uint4(1251092689, 2011681765, 749743684, 183784440);
+            uint4 b3 = uint4(486470891, 1709514236, 2145785285, 854254454);
+            bool4 r3 = bool4(false, false, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_equal_wide_scalar()
+        {
+            uint4 a0 = uint4(1722165358, 1219858357, 860410743, 411099660);
+            uint b0 = (1688048545);
+            bool4 r0 = bool4(false, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4 a1 = uint4(348104022, 212084836, 58924407, 1459242706);
+            uint b1 = (1963256951);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4 a2 = uint4(1745758438, 262559763, 690091301, 1806172431);
+            uint b2 = (532949158);
+            bool4 r2 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4 a3 = uint4(2091514001, 1617221948, 2017733017, 804204255);
+            uint b3 = (1857173043);
+            bool4 r3 = bool4(false, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint4 b0 = uint4(1181030049, 1787703989, 1729760948, 1816537388);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1359786460);
+            uint4 b1 = uint4(874999193, 1678863148, 1711365839, 762067160);
+            bool4 r1 = bool4(false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (11953554);
+            uint4 b2 = uint4(1131583906, 1175393186, 1293698493, 48893340);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (66196247);
+            uint4 b3 = uint4(1958607116, 1576473309, 861890786, 478252419);
+            bool4 r3 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_equal_wide_wide()
+        {
+            uint4 a0 = uint4(263000030, 744235661, 1893760267, 237248);
+            uint4 b0 = uint4(1395535146, 1178373944, 1237373760, 1364855321);
+            bool4 r0 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4 a1 = uint4(1062370984, 1676977687, 816766880, 1089431546);
+            uint4 b1 = uint4(600811864, 362060472, 290870624, 1839067862);
+            bool4 r1 = bool4(true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4 a2 = uint4(1394493730, 1176473380, 1193988637, 1703862455);
+            uint4 b2 = uint4(396958580, 1336888643, 1019684398, 1697684196);
+            bool4 r2 = bool4(true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4 a3 = uint4(1806186947, 1253571980, 589397635, 1951842887);
+            uint4 b3 = uint4(1227300220, 2044269675, 1898323839, 874509380);
+            bool4 r3 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_equal_wide_scalar()
+        {
+            uint4 a0 = uint4(2112791350, 1043657935, 101764761, 1529909067);
+            uint b0 = (1470533736);
+            bool4 r0 = bool4(true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4 a1 = uint4(556026890, 1186600258, 815093894, 609211196);
+            uint b1 = (281734132);
+            bool4 r1 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4 a2 = uint4(1604309397, 244604867, 1419295004, 471843809);
+            uint b2 = (829548642);
+            bool4 r2 = bool4(true, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4 a3 = uint4(1819986195, 1646290021, 196833647, 1596738181);
+            uint b3 = (1460027917);
+            bool4 r3 = bool4(true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint4 b0 = uint4(1503244746, 861711266, 817773856, 925984572);
+            bool4 r0 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (571221723);
+            uint4 b1 = uint4(683686810, 118252990, 1653952090, 1240253990);
+            bool4 r1 = bool4(false, true, false, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (1947039008);
+            uint4 b2 = uint4(1869136019, 152012637, 1214546726, 917376832);
+            bool4 r2 = bool4(true, true, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (303549425);
+            uint4 b3 = uint4(2111728811, 945321577, 173706579, 625318949);
+            bool4 r3 = bool4(false, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_add_wide_wide()
+        {
+            uint4 a0 = uint4(2049228671, 1658660009, 491719392, 937013355);
+            uint4 b0 = uint4(2088751567, 645762023, 306868786, 4360271);
+            uint4 r0 = uint4(4137980238, 2304422032, 798588178, 941373626);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4 a1 = uint4(81108663, 1063894558, 86954702, 843159721);
+            uint4 b1 = uint4(506047997, 2094559874, 1634712736, 1601474440);
+            uint4 r1 = uint4(587156660, 3158454432, 1721667438, 2444634161);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4 a2 = uint4(698977704, 192867135, 1683407172, 137301303);
+            uint4 b2 = uint4(1586485231, 908746788, 1812370320, 1247342357);
+            uint4 r2 = uint4(2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4 a3 = uint4(2103582820, 526139155, 447937230, 2127411006);
+            uint4 b3 = uint4(2043773873, 223363428, 175115707, 985928617);
+            uint4 r3 = uint4(4147356693, 749502583, 623052937, 3113339623);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_add_wide_scalar()
+        {
+            uint4 a0 = uint4(2038218457, 134923711, 875689667, 1338884463);
+            uint b0 = (2124409227);
+            uint4 r0 = uint4(4162627684, 2259332938, 3000098894, 3463293690);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4 a1 = uint4(997710928, 1067888129, 70433301, 2003021861);
+            uint b1 = (340490871);
+            uint4 r1 = uint4(1338201799, 1408379000, 410924172, 2343512732);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4 a2 = uint4(1635971971, 85446202, 1068152966, 1239387100);
+            uint b2 = (1160398286);
+            uint4 r2 = uint4(2796370257, 1245844488, 2228551252, 2399785386);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4 a3 = uint4(1497676888, 1095438654, 756559204, 1818718931);
+            uint b3 = (1727477485);
+            uint4 r3 = uint4(3225154373, 2822916139, 2484036689, 3546196416);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint4 b0 = uint4(519908870, 851424292, 328314822, 135622204);
+            uint4 r0 = uint4(911000948, 1242516370, 719406900, 526714282);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (740923360);
+            uint4 b1 = uint4(655394201, 1451896269, 1781697072, 996031825);
+            uint4 r1 = uint4(1396317561, 2192819629, 2522620432, 1736955185);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1557774949);
+            uint4 b2 = uint4(779774940, 1111541302, 783046445, 1130163944);
+            uint4 r2 = uint4(2337549889, 2669316251, 2340821394, 2687938893);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (288279584);
+            uint4 b3 = uint4(1397683861, 1636583489, 673263339, 1469300874);
+            uint4 r3 = uint4(1685963445, 1924863073, 961542923, 1757580458);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_sub_wide_wide()
+        {
+            uint4 a0 = uint4(1353441118, 797269833, 659988112, 56022121);
+            uint4 b0 = uint4(1332656812, 1827794007, 972557431, 2078233689);
+            uint4 r0 = uint4(20784306, 3264443122, 3982397977, 2272755728);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4 a1 = uint4(365847472, 2062899435, 1380988474, 799885138);
+            uint4 b1 = uint4(1508184327, 1372307701, 810327977, 936799885);
+            uint4 r1 = uint4(3152630441, 690591734, 570660497, 4158052549);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4 a2 = uint4(1306058185, 579775276, 1239163824, 344591081);
+            uint4 b2 = uint4(71562303, 1418723328, 1971342989, 1226053395);
+            uint4 r2 = uint4(1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4 a3 = uint4(86359575, 1049709943, 721529513, 1767221271);
+            uint4 b3 = uint4(136565478, 1979903295, 600719425, 837912956);
+            uint4 r3 = uint4(4244761393, 3364773944, 120810088, 929308315);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_sub_wide_scalar()
+        {
+            uint4 a0 = uint4(1176369558, 1934521195, 309452150, 1417634074);
+            uint b0 = (462232403);
+            uint4 r0 = uint4(714137155, 1472288792, 4142187043, 955401671);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4 a1 = uint4(108910717, 1502312334, 1451794815, 281174200);
+            uint b1 = (1306356714);
+            uint4 r1 = uint4(3097521299, 195955620, 145438101, 3269784782);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4 a2 = uint4(87530840, 2041593336, 557239990, 1119051448);
+            uint b2 = (1913724431);
+            uint4 r2 = uint4(2468773705, 127868905, 2938482855, 3500294313);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4 a3 = uint4(1590376732, 816382635, 815920639, 1829033117);
+            uint b3 = (819090189);
+            uint4 r3 = uint4(771286543, 4292259742, 4291797746, 1009942928);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint4 b0 = uint4(2022393810, 1612688515, 496689713, 887037586);
+            uint4 r0 = uint4(3964107891, 78845890, 1194844692, 804496819);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (2097630964);
+            uint4 b1 = uint4(374934538, 939035482, 935242277, 1789300421);
+            uint4 r1 = uint4(1722696426, 1158595482, 1162388687, 308330543);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (264712893);
+            uint4 b2 = uint4(1231856067, 1818112748, 1428436109, 1258745460);
+            uint4 r2 = uint4(3327824122, 2741567441, 3131244080, 3300934729);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1077380396);
+            uint4 b3 = uint4(1330722719, 518111829, 967128529, 344666254);
+            uint4 r3 = uint4(4041624973, 559268567, 110251867, 732714142);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mul_wide_wide()
+        {
+            uint4 a0 = uint4(245827027, 208934650, 1019478917, 568231809);
+            uint4 b0 = uint4(759663997, 350129201, 477450108, 1635735015);
+            uint4 r0 = uint4(3662155527, 1402281434, 332447596, 2361989735);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4 a1 = uint4(877289039, 1585782440, 2111178729, 1186019069);
+            uint4 b1 = uint4(388710278, 757722665, 1509388321, 1841703980);
+            uint4 r1 = uint4(2624048730, 1455036648, 2128344329, 3700879228);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4 a2 = uint4(571481445, 1570087048, 629447153, 619383734);
+            uint4 b2 = uint4(1826369331, 1524322467, 1605207974, 428419155);
+            uint4 r2 = uint4(2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4 a3 = uint4(2055121568, 700402816, 263414349, 187830569);
+            uint4 b3 = uint4(1460605791, 1968043860, 771161742, 2037340417);
+            uint4 r3 = uint4(990589280, 3356793344, 2953243830, 1156600361);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mul_wide_scalar()
+        {
+            uint4 a0 = uint4(1762033447, 465343930, 1570757881, 1326409563);
+            uint b0 = (1476837906);
+            uint4 r0 = uint4(2981789374, 1326807828, 2156411778, 4018813542);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4 a1 = uint4(1824319147, 72749215, 154616909, 975743632);
+            uint b1 = (1356578909);
+            uint4 r1 = uint4(4058582047, 130042307, 1244434425, 2313287248);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4 a2 = uint4(573770299, 971327747, 1818877398, 1324050764);
+            uint b2 = (1958912969);
+            uint4 r2 = uint4(3595344211, 583613531, 2609540870, 377032876);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4 a3 = uint4(660611671, 391009467, 1186856590, 890343818);
+            uint b3 = (1279757657);
+            uint4 r3 = uint4(4252425023, 1120105475, 4272141662, 1972017914);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint4 b0 = uint4(1764461774, 657072478, 1459784358, 1610646683);
+            uint4 r0 = uint4(3344568648, 4192918280, 1260585960, 1158730452);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (1632058826);
+            uint4 b1 = uint4(868441654, 1408757883, 335917146, 2105124483);
+            uint4 r1 = uint4(4237636764, 2735607822, 712546564, 3489634910);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1178393968);
+            uint4 b2 = uint4(1963904348, 1409533767, 243286231, 1336308795);
+            uint4 r2 = uint4(1196573760, 592673296, 209320208, 3942500560);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (517963367);
+            uint4 b3 = uint4(1733623488, 459880225, 994616533, 1420531535);
+            uint4 r3 = uint4(3520397120, 3023465543, 652617651, 2505294537);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_div_wide_wide()
+        {
+            uint4 a0 = uint4(1590198532, 507812502, 126627032, 1058247011);
+            uint4 b0 = uint4(1434703236, 911965201, 390415521, 128746927);
+            uint4 r0 = uint4(1, 0, 0, 8);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4 a1 = uint4(427387861, 290676154, 1829594484, 1127868739);
+            uint4 b1 = uint4(525835375, 816946613, 878264647, 146789678);
+            uint4 r1 = uint4(0, 0, 2, 7);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4 a2 = uint4(499016351, 1341209632, 134906097, 785470242);
+            uint4 b2 = uint4(2089524057, 254213018, 1916850021, 1737806518);
+            uint4 r2 = uint4(0, 5, 0, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4 a3 = uint4(788249865, 1099825433, 1552968283, 1822367139);
+            uint4 b3 = uint4(1906634983, 437754923, 825037958, 902508708);
+            uint4 r3 = uint4(0, 2, 1, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_div_wide_scalar()
+        {
+            uint4 a0 = uint4(560951562, 1218680769, 375341724, 1613542090);
+            uint b0 = (947861580);
+            uint4 r0 = uint4(0, 1, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4 a1 = uint4(1919409166, 1349573078, 524526253, 341995568);
+            uint b1 = (1397425408);
+            uint4 r1 = uint4(1, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4 a2 = uint4(495895326, 1676971657, 2131487088, 2105094094);
+            uint b2 = (1515313790);
+            uint4 r2 = uint4(0, 1, 1, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4 a3 = uint4(1017891310, 1646044372, 1447236569, 107215658);
+            uint b3 = (542666029);
+            uint4 r3 = uint4(1, 3, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint4 b0 = uint4(187325733, 1594107378, 2016183849, 1589343709);
+            uint4 r0 = uint4(6, 0, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (388768753);
+            uint4 b1 = uint4(1417077283, 1773486938, 1154044032, 81831373);
+            uint4 r1 = uint4(0, 0, 0, 4);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1476877645);
+            uint4 b2 = uint4(653688843, 45756703, 631027637, 396671391);
+            uint4 r2 = uint4(2, 32, 2, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (784365696);
+            uint4 b3 = uint4(1250594097, 1818363859, 1653451772, 270557729);
+            uint4 r3 = uint4(0, 0, 0, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mod_wide_wide()
+        {
+            uint4 a0 = uint4(146150818, 1846543305, 1071447756, 308965362);
+            uint4 b0 = uint4(983050390, 771341152, 942375212, 367361754);
+            uint4 r0 = uint4(146150818, 303861001, 129072544, 308965362);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4 a1 = uint4(659881575, 1002365460, 861198439, 1510617532);
+            uint4 b1 = uint4(749500619, 750718852, 2095151755, 88438806);
+            uint4 r1 = uint4(659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4 a2 = uint4(778525078, 1458458044, 101987897, 1249565173);
+            uint4 b2 = uint4(769227442, 647214624, 1026513788, 1544950956);
+            uint4 r2 = uint4(9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4 a3 = uint4(938026607, 1692541775, 1518877124, 1806965510);
+            uint4 b3 = uint4(160166322, 1099108075, 1158422232, 1798905209);
+            uint4 r3 = uint4(137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mod_wide_scalar()
+        {
+            uint4 a0 = uint4(164800505, 1062177828, 1898749675, 1701653318);
+            uint b0 = (883951171);
+            uint4 r0 = uint4(164800505, 178226657, 130847333, 817702147);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4 a1 = uint4(820393245, 128329633, 1464010899, 896587769);
+            uint b1 = (19002208);
+            uint4 r1 = uint4(3298301, 14316385, 840883, 3483993);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4 a2 = uint4(405208598, 959236935, 712321026, 172564850);
+            uint b2 = (1982762194);
+            uint4 r2 = uint4(405208598, 959236935, 712321026, 172564850);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4 a3 = uint4(1540068445, 1607489717, 165478511, 647846716);
+            uint b3 = (1085897743);
+            uint4 r3 = uint4(454170702, 521591974, 165478511, 647846716);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint4 b0 = uint4(740000543, 1556450291, 1104736385, 437976569);
+            uint4 r0 = uint4(242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1911837205);
+            uint4 b1 = uint4(1507212038, 1906405167, 247693265, 293460573);
+            uint4 r1 = uint4(404625167, 5432038, 177984350, 151073767);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (1495295166);
+            uint4 b2 = uint4(873323603, 530681233, 1298102643, 2057984657);
+            uint4 r2 = uint4(621971563, 433932700, 197192523, 1495295166);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1000742091);
+            uint4 b3 = uint4(1461372131, 1859742342, 797184687, 821888842);
+            uint4 r3 = uint4(1000742091, 1000742091, 203557404, 178853249);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_plus()
+        {
+            uint4 a0 = uint4(1643476803, 907898539, 379615839, 1140483021);
+            uint4 r0 = uint4(1643476803, 907898539, 379615839, 1140483021);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint4 a1 = uint4(1735287433, 1472881565, 339091479, 401565897);
+            uint4 r1 = uint4(1735287433, 1472881565, 339091479, 401565897);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint4 a2 = uint4(1287765427, 174532915, 1864850812, 1566098441);
+            uint4 r2 = uint4(1287765427, 174532915, 1864850812, 1566098441);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint4 a3 = uint4(1145639744, 2049663954, 1723005749, 409076474);
+            uint4 r3 = uint4(1145639744, 2049663954, 1723005749, 409076474);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_neg()
+        {
+            uint4 a0 = uint4(1955022112, 662160019, 370300775, 2141283773);
+            uint4 r0 = uint4(2339945184, 3632807277, 3924666521, 2153683523);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint4 a1 = uint4(1004505619, 33894270, 505708349, 1115028238);
+            uint4 r1 = uint4(3290461677, 4261073026, 3789258947, 3179939058);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint4 a2 = uint4(1636274969, 1542206286, 213087293, 243937487);
+            uint4 r2 = uint4(2658692327, 2752761010, 4081880003, 4051029809);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint4 a3 = uint4(341522275, 574159094, 1687250035, 2057919693);
+            uint4 r3 = uint4(3953445021, 3720808202, 2607717261, 2237047603);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_prefix_inc()
+        {
+            uint4 a0 = uint4(864455342, 2035793213, 1275443862, 971919915);
+            uint4 r0 = uint4(864455343, 2035793214, 1275443863, 971919916);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint4 a1 = uint4(411610189, 395072276, 115573442, 913293639);
+            uint4 r1 = uint4(411610190, 395072277, 115573443, 913293640);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint4 a2 = uint4(432884105, 1385544935, 1835605516, 831396561);
+            uint4 r2 = uint4(432884106, 1385544936, 1835605517, 831396562);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint4 a3 = uint4(388229350, 1786514683, 993189311, 752093909);
+            uint4 r3 = uint4(388229351, 1786514684, 993189312, 752093910);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_postfix_inc()
+        {
+            uint4 a0 = uint4(1751003569, 2063707595, 1500486291, 969189211);
+            uint4 r0 = uint4(1751003569, 2063707595, 1500486291, 969189211);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint4 a1 = uint4(1007848192, 1643023524, 1190630527, 1396179607);
+            uint4 r1 = uint4(1007848192, 1643023524, 1190630527, 1396179607);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint4 a2 = uint4(708474528, 1524860667, 1408994706, 375284401);
+            uint4 r2 = uint4(708474528, 1524860667, 1408994706, 375284401);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint4 a3 = uint4(1580130369, 717006530, 506142468, 732199129);
+            uint4 r3 = uint4(1580130369, 717006530, 506142468, 732199129);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_prefix_dec()
+        {
+            uint4 a0 = uint4(200904609, 871077500, 968578728, 638967721);
+            uint4 r0 = uint4(200904608, 871077499, 968578727, 638967720);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint4 a1 = uint4(1995396216, 1782514098, 1589827826, 1434377580);
+            uint4 r1 = uint4(1995396215, 1782514097, 1589827825, 1434377579);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint4 a2 = uint4(596759698, 1758478358, 1914114460, 71237375);
+            uint4 r2 = uint4(596759697, 1758478357, 1914114459, 71237374);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint4 a3 = uint4(389120307, 1310293956, 356565557, 18299409);
+            uint4 r3 = uint4(389120306, 1310293955, 356565556, 18299408);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_postfix_dec()
+        {
+            uint4 a0 = uint4(283970262, 1109329936, 1073216143, 649439137);
+            uint4 r0 = uint4(283970262, 1109329936, 1073216143, 649439137);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint4 a1 = uint4(1932646215, 484207852, 524156737, 691209285);
+            uint4 r1 = uint4(1932646215, 484207852, 524156737, 691209285);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint4 a2 = uint4(2017728859, 377162390, 526366486, 1504625034);
+            uint4 r2 = uint4(2017728859, 377162390, 526366486, 1504625034);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint4 a3 = uint4(590919177, 1867810045, 2095777993, 670715645);
+            uint4 r3 = uint4(590919177, 1867810045, 2095777993, 670715645);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_and_wide_wide()
+        {
+            uint4 a0 = uint4(779935043, 1097962163, 1939593304, 800599247);
+            uint4 b0 = uint4(307705143, 1710882162, 866836769, 532490608);
+            uint4 r0 = uint4(39064835, 1097961522, 864731136, 263727168);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4 a1 = uint4(952140918, 782792558, 1608557706, 396446406);
+            uint4 b1 = uint4(679371720, 1794035877, 1439832202, 519529812);
+            uint4 r1 = uint4(675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4 a2 = uint4(2039894114, 1286974642, 442394124, 1759739564);
+            uint4 b2 = uint4(23633139, 1209152681, 646737179, 1255867027);
+            uint4 r2 = uint4(16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4 a3 = uint4(233435438, 665207770, 1942050241, 1022352952);
+            uint4 b3 = uint4(1900854122, 413173763, 1409138251, 2087190272);
+            uint4 r3 = uint4(21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_and_wide_scalar()
+        {
+            uint4 a0 = uint4(443615469, 490057985, 2042441263, 1524760558);
+            uint b0 = (93423598);
+            uint4 r0 = uint4(1114348, 85033216, 26281518, 8488942);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4 a1 = uint4(1405175110, 1941875181, 1236735839, 1365509729);
+            uint b1 = (510212004);
+            uint4 r1 = uint4(306251012, 304619940, 136386308, 274728480);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4 a2 = uint4(428270198, 650270920, 1249238550, 814629680);
+            uint b2 = (607982857);
+            uint4 r2 = uint4(262144, 603983880, 3478528, 537657600);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4 a3 = uint4(1862276471, 861733033, 1408932942, 957693145);
+            uint b3 = (143502472);
+            uint4 r3 = uint4(134218752, 852104, 8948744, 134556808);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint4 b0 = uint4(420346723, 562416448, 1393127318, 1560699552);
+            uint4 r0 = uint4(547170, 18752, 1074284806, 1140867104);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (851218057);
+            uint4 b1 = uint4(703880958, 1159378889, 2031211279, 1089518981);
+            uint4 r1 = uint4(548671112, 1607305, 806388233, 11570305);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (270607307);
+            uint4 b2 = uint4(1349288930, 520199596, 1763483957, 1248975349);
+            uint4 r2 = uint4(270533570, 268501384, 8449, 2163137);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (236938635);
+            uint4 b3 = uint4(185023291, 1085233038, 1845693112, 946052961);
+            uint4 r3 = uint4(168239371, 1000842, 235077768, 134415617);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_or_wide_wide()
+        {
+            uint4 a0 = uint4(1731159103, 659068416, 382702471, 1821032196);
+            uint4 b0 = uint4(1583847161, 692672727, 1161585489, 1756207130);
+            uint4 r0 = uint4(2138044159, 793370327, 1476391895, 1823457054);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4 a1 = uint4(1565773438, 1004000514, 948501377, 600951835);
+            uint4 b1 = uint4(1321374429, 1287357212, 2075767170, 1273513430);
+            uint4 r1 = uint4(1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4 a2 = uint4(669346222, 396691477, 2108560248, 2117522137);
+            uint4 b2 = uint4(1610830169, 1316929125, 511625048, 573925879);
+            uint4 r2 = uint4(1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4 a3 = uint4(330307355, 818676817, 1774459567, 1117506257);
+            uint4 b3 = uint4(1502255628, 1841676448, 1682928938, 1115131952);
+            uint4 r3 = uint4(1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_or_wide_scalar()
+        {
+            uint4 a0 = uint4(961259683, 471103264, 1733389229, 1591585258);
+            uint b0 = (1666102508);
+            uint4 r0 = uint4(2068823279, 2136930284, 1734344685, 2145369582);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4 a1 = uint4(386953869, 1048929715, 1814263250, 860336789);
+            uint b1 = (1148351449);
+            uint4 r1 = uint4(1467118557, 2130147323, 1819506651, 2004349917);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4 a2 = uint4(1637162093, 774029856, 879300408, 1179087439);
+            uint b2 = (1227888278);
+            uint4 r2 = uint4(1773477631, 1865602742, 2105089982, 1333229279);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4 a3 = uint4(797240690, 46921989, 1980838747, 284225881);
+            uint b3 = (1977614655);
+            uint4 r3 = uint4(2145709439, 2011953471, 2012296063, 1978724735);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint4 b0 = uint4(1212928242, 1614462616, 936937728, 764766995);
+            uint4 r0 = uint4(1213978111, 1752940445, 2145094925, 1842867999);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (306352095);
+            uint4 b1 = uint4(574719481, 1283571271, 2109131012, 979469710);
+            uint4 r1 = uint4(843288575, 1589886943, 2146881503, 979603423);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (1348323481);
+            uint4 b2 = uint4(1407542578, 697517649, 1059093741, 627815046);
+            uint4 r2 = uint4(1409150395, 2044710617, 2138963197, 1971321503);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (418822515);
+            uint4 b3 = uint4(83214352, 424663473, 447949225, 527022375);
+            uint4 r3 = uint4(486013299, 436206067, 452442619, 536852855);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_xor_wide_wide()
+        {
+            uint4 a0 = uint4(1556324760, 207002929, 1843444873, 1632079131);
+            uint4 b0 = uint4(1054997548, 1523759632, 251164872, 110472397);
+            uint4 r0 = uint4(1646419380, 1451501345, 1662567489, 1741824470);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4 a1 = uint4(1460334334, 1607815585, 220623650, 38668553);
+            uint4 b1 = uint4(384031112, 1109163205, 535118981, 179106262);
+            uint4 r1 = uint4(1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4 a2 = uint4(47193340, 643663548, 1371932564, 94957188);
+            uint4 b2 = uint4(1523031711, 1713313372, 1294118730, 520360641);
+            uint4 r2 = uint4(1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4 a3 = uint4(700973621, 370621508, 2087573076, 351476570);
+            uint4 b3 = uint4(1040688781, 1020757245, 1143954843, 1281933464);
+            uint4 r3 = uint4(399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_xor_wide_scalar()
+        {
+            uint4 a0 = uint4(2124666952, 177397845, 574879617, 1937385541);
+            uint b0 = (493665894);
+            uint4 r0 = uint4(1674536494, 402546227, 1060063719, 1846973987);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4 a1 = uint4(1136545648, 535061373, 289301586, 1305234431);
+            uint b1 = (213863690);
+            uint4 r1 = uint4(1325466234, 324742775, 495003992, 1098057461);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4 a2 = uint4(353786540, 1267729267, 125659640, 1315625690);
+            uint b2 = (1308626970);
+            uint4 r2 = uint4(1528187574, 93328233, 1232959970, 6998720);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4 a3 = uint4(1730088797, 375757978, 491079274, 191750702);
+            uint b3 = (116862046);
+            uint4 r3 = uint4(1642603267, 278048964, 464677428, 228249200);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint4 b0 = uint4(1077599928, 884741329, 212164516, 1585020328);
+            uint4 r0 = uint4(217506340, 2020616269, 1080648504, 313868596);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (152985454);
+            uint4 b1 = uint4(1775851275, 1416249064, 1309317737, 1773918217);
+            uint4 r1 = uint4(1623656549, 1567908230, 1192543495, 1621460839);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1509843030);
+            uint4 b2 = uint4(1206045972, 1154916424, 1947871003, 1774252400);
+            uint4 r2 = uint4(505195842, 489209886, 769935181, 809406758);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1946113778);
+            uint4 b3 = uint4(1079717492, 290620937, 1382343363, 939045099);
+            uint4 r3 = uint4(866416774, 1655558395, 563852337, 1141368345);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_left_shift()
+        {
+            uint4 a0 = uint4(197771193, 622182602, 1283988958, 1327917304);
+            int b0 = (1321149625);
+            uint4 r0 = uint4(1912602624, 2483027968, 3154116608, 4026531840);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint4 a1 = uint4(473415985, 870301196, 2058433484, 1200694230);
+            int b1 = (432425717);
+            uint4 r1 = uint4(639631360, 3246391296, 2038431744, 2059403264);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint4 a2 = uint4(1531607705, 1008296534, 1447702302, 1079614371);
+            int b2 = (1360008038);
+            uint4 r2 = uint4(3533612608, 106468736, 2458634112, 375843008);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint4 a3 = uint4(35667343, 2045594989, 2077023268, 592678686);
+            int b3 = (1664454606);
+            uint4 r3 = uint4(258195456, 1398489088, 923336704, 3821502464);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_right_shift()
+        {
+            uint4 a0 = uint4(548167301, 1161338299, 1617625829, 1860731847);
+            int b0 = (1266801540);
+            uint4 r0 = uint4(34260456, 72583643, 101101614, 116295740);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint4 a1 = uint4(713958715, 770466193, 1265099998, 572763124);
+            int b1 = (196552656);
+            uint4 r1 = uint4(10894, 11756, 19303, 8739);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint4 a2 = uint4(506619530, 2031319045, 701927980, 917785020);
+            int b2 = (426807581);
+            uint4 r2 = uint4(0, 3, 1, 1);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint4 a3 = uint4(569504877, 1102123711, 334005460, 1624751550);
+            int b3 = (185593382);
+            uint4 r3 = uint4(8898513, 17220682, 5218835, 25386742);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_operator_bitwise_not()
+        {
+            uint4 a0 = uint4(1403358969, 831360921, 2088190243, 976721016);
+            uint4 r0 = uint4(2891608326, 3463606374, 2206777052, 3318246279);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint4 a1 = uint4(878283189, 1935567517, 1420884856, 472965491);
+            uint4 r1 = uint4(3416684106, 2359399778, 2874082439, 3822001804);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint4 a2 = uint4(771711426, 2061524024, 753208488, 2097179283);
+            uint4 r2 = uint4(3523255869, 2233443271, 3541758807, 2197788012);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint4 a3 = uint4(1303022493, 1289372466, 1635981125, 1951018596);
+            uint4 r3 = uint4(2991944802, 3005594829, 2658986170, 2343948699);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4_shuffle_result_1()
+        {
+            uint4 a = uint4(0, 1, 2, 3);
+            uint4 b = uint4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX), (0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY), (1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ), (2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW), (3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX), (4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY), (5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ), (6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW), (7));
+        }
+
+        [TestCompiler]
+        public static void uint4_shuffle_result_2()
+        {
+            uint4 a = uint4(0, 1, 2, 3);
+            uint4 b = uint4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), uint2(5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX), uint2(6, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint2(1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftW), uint2(7, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftZ), uint2(7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), uint2(2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW), uint2(5, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), uint2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightW), uint2(6, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ), uint2(5, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), uint2(6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.LeftX), uint2(7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), uint2(5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightY), uint2(7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), uint2(4, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW), uint2(1, 3));
+        }
+
+        [TestCompiler]
+        public static void uint4_shuffle_result_3()
+        {
+            uint4 a = uint4(0, 1, 2, 3);
+            uint4 b = uint4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightY), uint3(2, 7, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.LeftW), uint3(6, 0, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightW, ShuffleComponent.RightX), uint3(2, 7, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), uint3(5, 0, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), uint3(7, 6, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.LeftY), uint3(3, 1, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightX), uint3(3, 5, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightW), uint3(3, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.RightZ), uint3(6, 5, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), uint3(5, 4, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightW, ShuffleComponent.RightW, ShuffleComponent.LeftX), uint3(7, 7, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint3(6, 1, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightW), uint3(6, 1, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightY, ShuffleComponent.RightY), uint3(3, 5, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint3(6, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW), uint3(5, 1, 7));
+        }
+
+        [TestCompiler]
+        public static void uint4_shuffle_result_4()
+        {
+            uint4 a = uint4(0, 1, 2, 3);
+            uint4 b = uint4(4, 5, 6, 7);
+
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ), uint4(1, 3, 4, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftW, ShuffleComponent.RightZ, ShuffleComponent.RightZ), uint4(5, 3, 6, 6));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.RightW, ShuffleComponent.LeftZ), uint4(6, 6, 7, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ), uint4(4, 5, 2, 2));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), uint4(6, 1, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightW), uint4(4, 5, 5, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightW, ShuffleComponent.LeftX, ShuffleComponent.RightW), uint4(1, 7, 0, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftX), uint4(5, 0, 1, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightW, ShuffleComponent.LeftW, ShuffleComponent.LeftY), uint4(4, 7, 3, 1));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), uint4(5, 4, 1, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), uint4(0, 2, 6, 0));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightW, ShuffleComponent.RightW), uint4(2, 5, 7, 7));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightX, ShuffleComponent.LeftZ, ShuffleComponent.RightX), uint4(3, 4, 2, 4));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.LeftW), uint4(4, 0, 2, 3));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), uint4(6, 4, 0, 5));
+            TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY), uint4(3, 7, 1, 5));
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..b1ef89f358079336b1f72c0a28c54d8afec073a3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f91c46b1912b5d04d8e4e1ddb7377874
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..c1358accd9c994e1340eca839300c6b7810b625e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs
@@ -0,0 +1,1229 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint4x2
+    {
+        [TestCompiler]
+        public static void uint4x2_zero()
+        {
+            TestUtils.AreEqual(uint4x2.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c0.w, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c1.z, 0u);
+            TestUtils.AreEqual(uint4x2.zero.c1.w, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_equal_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370);
+            uint4x2 b0 = uint4x2(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x2 a1 = uint4x2(1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            uint4x2 b1 = uint4x2(1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x2 a2 = uint4x2(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint4x2 b2 = uint4x2(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x2 a3 = uint4x2(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            uint4x2 b3 = uint4x2(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_equal_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277);
+            uint b0 = (746972502);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x2 a1 = uint4x2(1682018538, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210, 969511077);
+            uint b1 = (795585660);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x2 a2 = uint4x2(442746747, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678);
+            uint b2 = (1772925698);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x2 a3 = uint4x2(1305479811, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832);
+            uint b3 = (255635293);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint4x2 b0 = uint4x2(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124);
+            bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (1061805787);
+            uint4x2 b1 = uint4x2(1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000, 455818693);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (2003197687);
+            uint4x2 b2 = uint4x2(1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (367814403);
+            uint4x2 b3 = uint4x2(1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_not_equal_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646);
+            uint4x2 b0 = uint4x2(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x2 a1 = uint4x2(1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            uint4x2 b1 = uint4x2(1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x2 a2 = uint4x2(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint4x2 b2 = uint4x2(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x2 a3 = uint4x2(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            uint4x2 b3 = uint4x2(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_not_equal_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450);
+            uint b0 = (248693828);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x2 a1 = uint4x2(2105962247, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730, 1412347883);
+            uint b1 = (727205263);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x2 a2 = uint4x2(1622176923, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685);
+            uint b2 = (768370497);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x2 a3 = uint4x2(904014575, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907);
+            uint b3 = (384643370);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint4x2 b0 = uint4x2(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (124108032);
+            uint4x2 b1 = uint4x2(1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247, 472172806);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (266984506);
+            uint4x2 b2 = uint4x2(2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350);
+            bool4x2 r2 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (572038024);
+            uint4x2 b3 = uint4x2(1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973);
+            uint4x2 b0 = uint4x2(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202);
+            bool4x2 r0 = bool4x2(false, true, false, false, false, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x2 a1 = uint4x2(928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            uint4x2 b1 = uint4x2(2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x2 a2 = uint4x2(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint4x2 b2 = uint4x2(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool4x2 r2 = bool4x2(true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x2 a3 = uint4x2(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            uint4x2 b3 = uint4x2(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool4x2 r3 = bool4x2(false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341);
+            uint b0 = (1491216667);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, false, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x2 a1 = uint4x2(840091491, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901, 1127696709);
+            uint b1 = (469591900);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x2 a2 = uint4x2(1286331950, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110);
+            uint b2 = (380753337);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x2 a3 = uint4x2(867559111, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996);
+            uint b3 = (1703747625);
+            bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint4x2 b0 = uint4x2(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255);
+            bool4x2 r0 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (111349251);
+            uint4x2 b1 = uint4x2(1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010, 1596056507);
+            bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1027318999);
+            uint4x2 b2 = uint4x2(146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400);
+            bool4x2 r2 = bool4x2(false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (1329939911);
+            uint4x2 b3 = uint4x2(1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550);
+            uint4x2 b0 = uint4x2(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742);
+            bool4x2 r0 = bool4x2(true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x2 a1 = uint4x2(2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            uint4x2 b1 = uint4x2(910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool4x2 r1 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x2 a2 = uint4x2(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint4x2 b2 = uint4x2(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x2 a3 = uint4x2(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            uint4x2 b3 = uint4x2(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool4x2 r3 = bool4x2(true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035);
+            uint b0 = (438688675);
+            bool4x2 r0 = bool4x2(true, false, true, false, false, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x2 a1 = uint4x2(2125058448, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717, 1016617211);
+            uint b1 = (304028799);
+            bool4x2 r1 = bool4x2(true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x2 a2 = uint4x2(2063134811, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419);
+            uint b2 = (1577403353);
+            bool4x2 r2 = bool4x2(true, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x2 a3 = uint4x2(1058332184, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708);
+            uint b3 = (524569092);
+            bool4x2 r3 = bool4x2(true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint4x2 b0 = uint4x2(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735);
+            bool4x2 r0 = bool4x2(true, true, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (691047512);
+            uint4x2 b1 = uint4x2(741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098, 1052151621);
+            bool4x2 r1 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1023307544);
+            uint4x2 b2 = uint4x2(1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900);
+            bool4x2 r2 = bool4x2(false, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (315569296);
+            uint4x2 b3 = uint4x2(292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844);
+            bool4x2 r3 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_equal_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394);
+            uint4x2 b0 = uint4x2(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595);
+            bool4x2 r0 = bool4x2(false, true, false, true, true, false, false, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x2 a1 = uint4x2(117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            uint4x2 b1 = uint4x2(1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool4x2 r1 = bool4x2(true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x2 a2 = uint4x2(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint4x2 b2 = uint4x2(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool4x2 r2 = bool4x2(true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x2 a3 = uint4x2(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            uint4x2 b3 = uint4x2(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool4x2 r3 = bool4x2(false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_equal_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407);
+            uint b0 = (1688048545);
+            bool4x2 r0 = bool4x2(false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x2 a1 = uint4x2(1459242706, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043, 1617221948);
+            uint b1 = (1745758438);
+            bool4x2 r1 = bool4x2(true, true, true, true, false, false, false, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x2 a2 = uint4x2(2017733017, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750);
+            uint b2 = (804204255);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x2 a3 = uint4x2(1258115260, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122);
+            uint b3 = (20607406);
+            bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint4x2 b0 = uint4x2(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (762067160);
+            uint4x2 b1 = uint4x2(11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116, 1576473309);
+            bool4x2 r1 = bool4x2(false, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (861890786);
+            uint4x2 b2 = uint4x2(478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850);
+            bool4x2 r2 = bool4x2(false, true, false, true, false, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (830430286);
+            uint4x2 b3 = uint4x2(145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788);
+            bool4x2 r3 = bool4x2(false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_equal_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546);
+            uint4x2 b0 = uint4x2(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862);
+            bool4x2 r0 = bool4x2(false, false, true, false, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x2 a1 = uint4x2(1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            uint4x2 b1 = uint4x2(396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool4x2 r1 = bool4x2(true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x2 a2 = uint4x2(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint4x2 b2 = uint4x2(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool4x2 r2 = bool4x2(false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x2 a3 = uint4x2(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            uint4x2 b3 = uint4x2(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool4x2 r3 = bool4x2(false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_equal_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894);
+            uint b0 = (1470533736);
+            bool4x2 r0 = bool4x2(true, false, false, true, false, false, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x2 a1 = uint4x2(609211196, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917, 1646290021);
+            uint b1 = (1604309397);
+            bool4x2 r1 = bool4x2(false, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x2 a2 = uint4x2(196833647, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607);
+            uint b2 = (1596738181);
+            bool4x2 r2 = bool4x2(false, true, true, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x2 a3 = uint4x2(1223010129, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090);
+            uint b3 = (379014762);
+            bool4x2 r3 = bool4x2(true, true, false, true, true, false, true, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint4x2 b0 = uint4x2(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090);
+            bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (1240253990);
+            uint4x2 b1 = uint4x2(1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811, 945321577);
+            bool4x2 r1 = bool4x2(false, false, true, true, true, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (173706579);
+            uint4x2 b2 = uint4x2(625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452);
+            bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (233894308);
+            uint4x2 b3 = uint4x2(479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835);
+            bool4x2 r3 = bool4x2(false, false, true, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_add_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721);
+            uint4x2 b0 = uint4x2(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440);
+            uint4x2 r0 = uint4x2(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x2 a1 = uint4x2(698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            uint4x2 b1 = uint4x2(1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            uint4x2 r1 = uint4x2(2285462935, 1101613923, 3495777492, 1384643660, 4147356693, 749502583, 623052937, 3113339623);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x2 a2 = uint4x2(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint4x2 b2 = uint4x2(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint4x2 r2 = uint4x2(2178242226, 3146426160, 1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x2 a3 = uint4x2(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            uint4x2 b3 = uint4x2(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            uint4x2 r3 = uint4x2(3048865720, 2901392143, 1940611170, 1099044556, 2362767916, 1285092016, 2641863205, 3757383291);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_add_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301);
+            uint b0 = (2124409227);
+            uint4x2 r0 = uint4x2(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x2 a1 = uint4x2(2003021861, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485, 1095438654);
+            uint b1 = (1635971971);
+            uint4x2 r1 = uint4x2(3638993832, 2796370257, 1721418173, 2704124937, 2875359071, 3133648859, 3363449456, 2731410625);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x2 a2 = uint4x2(756559204, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260);
+            uint b2 = (1818718931);
+            uint4x2 r2 = uint4x2(2575278135, 2477642483, 3429237852, 3404474329, 2511562231, 2887312400, 3523495164, 2396501191);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x2 a3 = uint4x2(736972565, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516);
+            uint b3 = (711894571);
+            uint4x2 r3 = uint4x2(1448867136, 1276152010, 2763630854, 2284732268, 2339901116, 2567594834, 1368643353, 984669087);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint4x2 b0 = uint4x2(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072);
+            uint4x2 r0 = uint4x2(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (996031825);
+            uint4x2 b1 = uint4x2(1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861, 1636583489);
+            uint4x2 r1 = uint4x2(2553806774, 1775806765, 2107573127, 1779078270, 2126195769, 1284311409, 2393715686, 2632615314);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (673263339);
+            uint4x2 b2 = uint4x2(1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839);
+            uint4x2 r2 = uint4x2(2142564213, 688119304, 1789900338, 2162126639, 2274254225, 863914640, 1980723107, 1593349178);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (2082229835);
+            uint4x2 b3 = uint4x2(1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222);
+            uint4x2 r3 = uint4x2(4074635409, 3296154293, 2588071287, 3063650997, 3570567534, 3196056475, 3888376343, 3924021057);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_sub_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138);
+            uint4x2 b0 = uint4x2(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885);
+            uint4x2 r0 = uint4x2(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x2 a1 = uint4x2(1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            uint4x2 b1 = uint4x2(71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            uint4x2 r1 = uint4x2(1234495882, 3456019244, 3562788131, 3413504982, 4244761393, 3364773944, 120810088, 929308315);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x2 a2 = uint4x2(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint4x2 b2 = uint4x2(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint4x2 r2 = uint4x2(3670565287, 4129068219, 3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x2 a3 = uint4x2(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            uint4x2 b3 = uint4x2(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            uint4x2 r3 = uint4x2(4111227161, 972642792, 3745373142, 2826807304, 3564332942, 1218011798, 1846728662, 3739059778);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_sub_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815);
+            uint b0 = (462232403);
+            uint4x2 r0 = uint4x2(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x2 a1 = uint4x2(281174200, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189, 816382635);
+            uint b1 = (87530840);
+            uint4x2 r1 = uint4x2(193643360, 1826193591, 1954062496, 469709150, 1031520608, 1502845892, 731559349, 728851795);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x2 a2 = uint4x2(815920639, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794);
+            uint b2 = (1829033117);
+            uint4x2 r2 = uint4x2(3281854818, 4258736111, 3579374728, 3884872155, 3743191368, 263746281, 3108170921, 4071184973);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x2 a3 = uint4x2(819644478, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500);
+            uint b3 = (1468003019);
+            uint4x2 r3 = uint4x2(3646608755, 2955267463, 3380458534, 3844091248, 531741763, 549269739, 349988745, 4107949777);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint4x2 b0 = uint4x2(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277);
+            uint4x2 r0 = uint4x2(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (1789300421);
+            uint4x2 b1 = uint4x2(264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719, 518111829);
+            uint4x2 r1 = uint4x2(1524587528, 557444354, 4266154969, 360864312, 530554961, 711920025, 458577702, 1271188592);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (967128529);
+            uint4x2 b2 = uint4x2(344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709);
+            uint4x2 r2 = uint4x2(622462275, 4179827907, 59261833, 3445210702, 506787961, 4974031, 410015068, 3560879116);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (1980098777);
+            uint4x2 b3 = uint4x2(730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041);
+            uint4x2 r3 = uint4x2(1250038225, 535700950, 1126528221, 1841262345, 966908349, 1262009247, 1473341387, 763650736);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mul_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069);
+            uint4x2 b0 = uint4x2(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980);
+            uint4x2 r0 = uint4x2(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x2 a1 = uint4x2(571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            uint4x2 b1 = uint4x2(1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            uint4x2 r1 = uint4x2(2640799263, 2093463192, 3087460678, 3161406466, 990589280, 3356793344, 2953243830, 1156600361);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x2 a2 = uint4x2(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint4x2 b2 = uint4x2(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint4x2 r2 = uint4x2(649177976, 678952165, 1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x2 a3 = uint4x2(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            uint4x2 b3 = uint4x2(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            uint4x2 r3 = uint4x2(1891467339, 335415735, 1128927428, 2638713520, 2861115658, 479369680, 3928339236, 4044803354);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mul_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909);
+            uint b0 = (1476837906);
+            uint4x2 r0 = uint4x2(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x2 a1 = uint4x2(975743632, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657, 391009467);
+            uint b1 = (573770299);
+            uint4x2 r1 = uint4x2(414773040, 3595344211, 1045098929, 3165813842, 1954692228, 970215437, 1522404739, 631100697);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x2 a2 = uint4x2(1186856590, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703);
+            uint b2 = (890343818);
+            uint4x2 r2 = uint4x2(218605196, 908725324, 3489887282, 2766521704, 1365477062, 1262261996, 2040090952, 691203142);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x2 a3 = uint4x2(1613845584, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051);
+            uint b3 = (76318055);
+            uint4x2 r3 = uint4x2(2959506480, 1256424448, 3749667707, 628661398, 357366566, 753276674, 2132219401, 3469671949);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint4x2 b0 = uint4x2(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146);
+            uint4x2 r0 = uint4x2(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (2105124483);
+            uint4x2 b1 = uint4x2(1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488, 459880225);
+            uint4x2 r1 = uint4x2(3266048080, 2084093460, 1286996821, 910923781, 1886305329, 3255007413, 644799552, 1815059427);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (994616533);
+            uint4x2 b2 = uint4x2(1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330);
+            uint4x2 r2 = uint4x2(585859259, 2021158292, 1046891801, 2353145761, 3556190869, 2579715257, 4134395107, 1259643370);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (1186460236);
+            uint4x2 b3 = uint4x2(657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873);
+            uint4x2 r3 = uint4x2(3393334220, 3415667152, 1278776548, 1761940324, 3619679884, 2049744268, 3919669496, 2350571308);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_div_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739);
+            uint4x2 b0 = uint4x2(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678);
+            uint4x2 r0 = uint4x2(1, 0, 0, 8, 0, 0, 2, 7);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x2 a1 = uint4x2(499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            uint4x2 b1 = uint4x2(2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            uint4x2 r1 = uint4x2(0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x2 a2 = uint4x2(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint4x2 b2 = uint4x2(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint4x2 r2 = uint4x2(1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x2 a3 = uint4x2(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            uint4x2 b3 = uint4x2(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            uint4x2 r3 = uint4x2(2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_div_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253);
+            uint b0 = (947861580);
+            uint4x2 r0 = uint4x2(0, 1, 0, 1, 2, 1, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x2 a1 = uint4x2(341995568, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029, 1646044372);
+            uint b1 = (495895326);
+            uint4x2 r1 = uint4x2(0, 3, 3, 4, 4, 2, 1, 3);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x2 a2 = uint4x2(1447236569, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924);
+            uint b2 = (107215658);
+            uint4x2 r2 = uint4x2(13, 0, 8, 6, 11, 13, 16, 17);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x2 a3 = uint4x2(1244966864, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348);
+            uint b3 = (1200843642);
+            uint4x2 r3 = uint4x2(1, 0, 1, 1, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint4x2 b0 = uint4x2(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032);
+            uint4x2 r0 = uint4x2(6, 0, 0, 0, 2, 0, 0, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (81831373);
+            uint4x2 b1 = uint4x2(1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097, 1818363859);
+            uint4x2 r1 = uint4x2(0, 0, 1, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1653451772);
+            uint4x2 b2 = uint4x2(270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890);
+            uint4x2 r2 = uint4x2(6, 33, 0, 1, 1, 0, 2, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (351914083);
+            uint4x2 b3 = uint4x2(131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708);
+            uint4x2 r3 = uint4x2(2, 0, 0, 0, 1, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mod_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532);
+            uint4x2 b0 = uint4x2(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806);
+            uint4x2 r0 = uint4x2(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x2 a1 = uint4x2(778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            uint4x2 b1 = uint4x2(769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            uint4x2 r1 = uint4x2(9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x2 a2 = uint4x2(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint4x2 b2 = uint4x2(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint4x2 r2 = uint4x2(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x2 a3 = uint4x2(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            uint4x2 b3 = uint4x2(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            uint4x2 r3 = uint4x2(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mod_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899);
+            uint b0 = (883951171);
+            uint4x2 r0 = uint4x2(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x2 a1 = uint4x2(896587769, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743, 1607489717);
+            uint b1 = (405208598);
+            uint4x2 r1 = uint4x2(86170573, 361927802, 148819739, 307112428, 172564850, 324442651, 275480547, 391863923);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x2 a2 = uint4x2(165478511, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313);
+            uint b2 = (647846716);
+            uint4x2 r2 = uint4x2(165478511, 267861283, 307136969, 280344567, 437088090, 488509689, 144280764, 377501313);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x2 a3 = uint4x2(1778384846, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942);
+            uint b3 = (1216011754);
+            uint4x2 r3 = uint4x2(562373092, 812183417, 1153802502, 426660116, 708698988, 665297470, 352079071, 834971188);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint4x2 b0 = uint4x2(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265);
+            uint4x2 r0 = uint4x2(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (293460573);
+            uint4x2 b1 = uint4x2(1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131, 1859742342);
+            uint4x2 r1 = uint4x2(293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573, 293460573);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (797184687);
+            uint4x2 b2 = uint4x2(821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318);
+            uint4x2 r2 = uint4x2(797184687, 797184687, 797184687, 797184687, 182024723, 797184687, 1919391, 797184687);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (164578061);
+            uint4x2 b3 = uint4x2(730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733);
+            uint4x2 r3 = uint4x2(164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061, 164578061);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_plus()
+        {
+            uint4x2 a0 = uint4x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            uint4x2 r0 = uint4x2(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint4x2 a1 = uint4x2(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            uint4x2 r1 = uint4x2(401565897, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926, 2049663954);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint4x2 a2 = uint4x2(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            uint4x2 r2 = uint4x2(1723005749, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint4x2 a3 = uint4x2(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            uint4x2 r3 = uint4x2(1575280693, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_neg()
+        {
+            uint4x2 a0 = uint4x2(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349);
+            uint4x2 r0 = uint4x2(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint4x2 a1 = uint4x2(1115028238, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242, 574159094);
+            uint4x2 r1 = uint4x2(3179939058, 3599972203, 2752761010, 4081880003, 4051029809, 3953445021, 3453882054, 3720808202);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint4x2 a2 = uint4x2(1687250035, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928);
+            uint4x2 r2 = uint4x2(2607717261, 3119952564, 3035158223, 3082501970, 3104397376, 2247011524, 2174237432, 2854192368);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint4x2 a3 = uint4x2(1485596454, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098);
+            uint4x2 r3 = uint4x2(2809370842, 2907365578, 2549315298, 3975851670, 3175007490, 3555835012, 2340793982, 2585110198);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_prefix_inc()
+        {
+            uint4x2 a0 = uint4x2(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442);
+            uint4x2 r0 = uint4x2(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint4x2 a1 = uint4x2(913293639, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402, 1786514683);
+            uint4x2 r1 = uint4x2(913293640, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403, 1786514684);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint4x2 a2 = uint4x2(993189311, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865);
+            uint4x2 r2 = uint4x2(993189312, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint4x2 a3 = uint4x2(519296647, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208);
+            uint4x2 r3 = uint4x2(519296648, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_postfix_inc()
+        {
+            uint4x2 a0 = uint4x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            uint4x2 r0 = uint4x2(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint4x2 a1 = uint4x2(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            uint4x2 r1 = uint4x2(1396179607, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778, 717006530);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint4x2 a2 = uint4x2(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            uint4x2 r2 = uint4x2(506142468, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint4x2 a3 = uint4x2(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            uint4x2 r3 = uint4x2(1468020171, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_prefix_dec()
+        {
+            uint4x2 a0 = uint4x2(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826);
+            uint4x2 r0 = uint4x2(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint4x2 a1 = uint4x2(1434377580, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392, 1310293956);
+            uint4x2 r1 = uint4x2(1434377579, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391, 1310293955);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint4x2 a2 = uint4x2(356565557, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829);
+            uint4x2 r2 = uint4x2(356565556, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint4x2 a3 = uint4x2(1454322707, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343);
+            uint4x2 r3 = uint4x2(1454322706, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_postfix_dec()
+        {
+            uint4x2 a0 = uint4x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            uint4x2 r0 = uint4x2(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint4x2 a1 = uint4x2(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            uint4x2 r1 = uint4x2(691209285, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868, 1867810045);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint4x2 a2 = uint4x2(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            uint4x2 r2 = uint4x2(2095777993, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint4x2 a3 = uint4x2(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            uint4x2 r3 = uint4x2(1726583208, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_and_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406);
+            uint4x2 b0 = uint4x2(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812);
+            uint4x2 r0 = uint4x2(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x2 a1 = uint4x2(2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            uint4x2 b1 = uint4x2(23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            uint4x2 r1 = uint4x2(16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x2 a2 = uint4x2(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint4x2 b2 = uint4x2(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint4x2 r2 = uint4x2(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x2 a3 = uint4x2(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            uint4x2 b3 = uint4x2(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            uint4x2 r3 = uint4x2(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_and_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839);
+            uint b0 = (93423598);
+            uint4x2 r0 = uint4x2(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x2 a1 = uint4x2(1365509729, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472, 861733033);
+            uint b1 = (428270198);
+            uint4x2 r1 = uint4x2(285475424, 262144, 8536128, 134529558, 277234224, 150995062, 142909440, 285474848);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x2 a2 = uint4x2(1408932942, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926);
+            uint b2 = (957693145);
+            uint4x2 r2 = uint4x2(286268488, 420556880, 18167000, 286270481, 420753408, 134551616, 152314057, 420547656);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x2 a3 = uint4x2(1817145060, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525);
+            uint b3 = (1466722981);
+            uint4x2 r3 = uint4x2(1145858724, 1145069572, 273443365, 101460005, 1093403136, 524420, 335806629, 1142948357);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint4x2 b0 = uint4x2(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279);
+            uint4x2 r0 = uint4x2(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1089518981);
+            uint4x2 b1 = uint4x2(270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291, 1085233038);
+            uint4x2 r1 = uint4x2(2105729, 1080066432, 40324, 1074831621, 1081121157, 1058177, 14593, 1084233092);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1845693112);
+            uint4x2 b2 = uint4x2(946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417);
+            uint4x2 r2 = uint4x2(671287840, 1141047992, 1744964224, 33751056, 1744964256, 1845559864, 1140852752, 1208158384);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1214109404);
+            uint4x2 b3 = uint4x2(2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506);
+            uint4x2 r3 = uint4x2(16988, 1208799884, 1074321052, 1209303624, 1115840, 1213727936, 1610312, 1078218760);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_or_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835);
+            uint4x2 b0 = uint4x2(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430);
+            uint4x2 r0 = uint4x2(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x2 a1 = uint4x2(669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            uint4x2 b1 = uint4x2(1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            uint4x2 r1 = uint4x2(1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x2 a2 = uint4x2(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint4x2 b2 = uint4x2(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint4x2 r2 = uint4x2(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x2 a3 = uint4x2(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            uint4x2 b3 = uint4x2(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            uint4x2 r3 = uint4x2(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_or_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250);
+            uint b0 = (1666102508);
+            uint4x2 r0 = uint4x2(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x2 a1 = uint4x2(860336789, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655, 46921989);
+            uint b1 = (1637162093);
+            uint4x2 r1 = uint4x2(1943518973, 1773477631, 1874321005, 1979522941, 1742175855, 1872100735, 1978998143, 1675623789);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x2 a2 = uint4x2(1980838747, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359);
+            uint b2 = (284225881);
+            uint4x2 r2 = uint4x2(1995567963, 334885881, 317847551, 1408563035, 1895366623, 536016891, 2029779967, 2063332319);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x2 a3 = uint4x2(1511253082, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895);
+            uint b3 = (1775629833);
+            uint4x2 r3 = uint4x2(2077750875, 1843265467, 1775761279, 2111176313, 2046817999, 2113404623, 1778251405, 2077753039);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint4x2 b0 = uint4x2(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012);
+            uint4x2 r0 = uint4x2(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (979469710);
+            uint4x2 b1 = uint4x2(1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352, 424663473);
+            uint4x2 r1 = uint4x2(2055064991, 2078664126, 1005832159, 1063386607, 1064023950, 989314559, 1056294302, 997187007);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (447949225);
+            uint4x2 b2 = uint4x2(527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150);
+            uint4x2 r2 = uint4x2(536590767, 2126457261, 447999469, 1526184941, 2062773753, 1593519101, 1589357545, 1526197231);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (298563808);
+            uint4x2 b3 = uint4x2(2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556);
+            uint4x2 r3 = uint4x2(2078276845, 872414207, 938213110, 1945092072, 1375468774, 838844392, 1004273386, 836763636);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_xor_wide_wide()
+        {
+            uint4x2 a0 = uint4x2(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553);
+            uint4x2 b0 = uint4x2(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262);
+            uint4x2 r0 = uint4x2(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x2 a1 = uint4x2(47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            uint4x2 b1 = uint4x2(1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            uint4x2 r1 = uint4x2(1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x2 a2 = uint4x2(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint4x2 b2 = uint4x2(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint4x2 r2 = uint4x2(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x2 a3 = uint4x2(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            uint4x2 b3 = uint4x2(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            uint4x2 r3 = uint4x2(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_xor_wide_scalar()
+        {
+            uint4x2 a0 = uint4x2(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586);
+            uint b0 = (493665894);
+            uint4x2 r0 = uint4x2(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x2 a1 = uint4x2(1305234431, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046, 375757978);
+            uint b1 = (353786540);
+            uint4x2 r1 = uint4x2(1490686291, 1528187574, 1585863135, 309015380, 1534886006, 1913214449, 333543154, 57919030);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x2 a2 = uint4x2(491079274, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736);
+            uint b2 = (191750702);
+            uint4x2 r2 = uint4x2(371762244, 4897915, 852093491, 732592657, 763363694, 190966742, 1397197090, 1867453430);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x2 a3 = uint4x2(447453839, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291);
+            uint b3 = (890841598);
+            uint4x2 r3 = uint4x2(800240497, 610664066, 711808497, 714187902, 1735978412, 1929239075, 171965729, 427463573);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint4x2 b0 = uint4x2(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737);
+            uint4x2 r0 = uint4x2(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1773918217);
+            uint4x2 b1 = uint4x2(1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492, 290620937);
+            uint4x2 r1 = uint4x2(809875551, 777590045, 762148929, 497155858, 8071545, 440700667, 702609021, 2028559872);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (1382343363);
+            uint4x2 b2 = uint4x2(939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481);
+            uint4x2 r2 = uint4x2(1704743464, 476745462, 1598742512, 1722301941, 1981778335, 1509285046, 19333242, 1884605034);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (1813817520);
+            uint4x2 b3 = uint4x2(86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759);
+            uint4x2 r3 = uint4x2(1765145501, 465338881, 961174309, 1508358725, 916626445, 1734574159, 1183306712, 2052237431);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_left_shift()
+        {
+            uint4x2 a0 = uint4x2(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484);
+            int b0 = (1321149625);
+            uint4x2 r0 = uint4x2(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint4x2 a1 = uint4x2(1200694230, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606, 2045594989);
+            int b1 = (1531607705);
+            uint4x2 r1 = uint4x2(2885681152, 3422552064, 2885681152, 1006632960, 1174405120, 503316480, 2617245696, 3657433088);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint4x2 a2 = uint4x2(2077023268, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278);
+            int b2 = (592678686);
+            uint4x2 r2 = uint4x2(0, 3221225472, 3221225472, 3221225472, 1073741824, 1073741824, 1073741824, 2147483648);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint4x2 a3 = uint4x2(221147365, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688);
+            int b3 = (2084190583);
+            uint4x2 r3 = uint4x2(1920991232, 2952790016, 3690987520, 4160749568, 3489660928, 3984588800, 109051904, 1207959552);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_right_shift()
+        {
+            uint4x2 a0 = uint4x2(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998);
+            int b0 = (1266801540);
+            uint4x2 r0 = uint4x2(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint4x2 a1 = uint4x2(572763124, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382, 1102123711);
+            int b1 = (506619530);
+            uint4x2 r1 = uint4x2(559338, 416804, 1983710, 685476, 896274, 556157, 181243, 1076292);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint4x2 a2 = uint4x2(334005460, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760);
+            int b2 = (1624751550);
+            uint4x2 r2 = uint4x2(0, 0, 1, 1, 0, 1, 0, 0);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint4x2 a3 = uint4x2(348013684, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476);
+            int b3 = (1568185874);
+            uint4x2 r3 = uint4x2(1327, 2953, 6054, 2289, 112, 7175, 1343, 4442);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x2_operator_bitwise_not()
+        {
+            uint4x2 a0 = uint4x2(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856);
+            uint4x2 r0 = uint4x2(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint4x2 a1 = uint4x2(472965491, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603, 1289372466);
+            uint4x2 r1 = uint4x2(3822001804, 3667386335, 2233443271, 3541758807, 2197788012, 2991944802, 3630222692, 3005594829);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint4x2 a2 = uint4x2(1635981125, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942);
+            uint4x2 r2 = uint4x2(2658986170, 2749315358, 3577030838, 3010462608, 2952181910, 3425337820, 2249112974, 3012420353);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint4x2 a3 = uint4x2(1562433528, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039);
+            uint4x2 r3 = uint4x2(2732533767, 2558396580, 3786061237, 2234214415, 2427548539, 3906437021, 3599787443, 2528029256);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..89848b5b2104cbfe366784116c0dd72c6f123356
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x2.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 89ef12b5bac48bb47b957005fa49bd89
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..2db3b302d51d6dd61e00e48975fc1ef0b2b5e2db
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs
@@ -0,0 +1,1233 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint4x3
+    {
+        [TestCompiler]
+        public static void uint4x3_zero()
+        {
+            TestUtils.AreEqual(uint4x3.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c0.w, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c1.z, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c1.w, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c2.y, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c2.z, 0u);
+            TestUtils.AreEqual(uint4x3.zero.c2.w, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_equal_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222);
+            uint4x3 b0 = uint4x3(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x3 a1 = uint4x3(1469608940, 869874758, 458603090, 581282460, 1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509);
+            uint4x3 b1 = uint4x3(36812057, 543224481, 1565350150, 1909926604, 1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x3 a2 = uint4x3(1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771, 929607871, 2092475304, 1940221590, 196567546);
+            uint4x3 b2 = uint4x3(708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603, 91580624, 1974459648, 2074899534, 164782857);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x3 a3 = uint4x3(346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            uint4x3 b3 = uint4x3(1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_equal_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411);
+            uint b0 = (746972502);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x3 a1 = uint4x3(672785749, 585324157, 404448210, 969511077, 442746747, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005);
+            uint b1 = (1465584610);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x3 a2 = uint4x3(211986678, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966, 1684122010, 1962874832, 172230876, 496695881, 955604291);
+            uint b2 = (1305479811);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x3 a3 = uint4x3(872759249, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886, 20195989);
+            uint b3 = (811880239);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint4x3 b0 = uint4x3(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064);
+            bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (737210539);
+            uint4x3 b1 = uint4x3(1737844479, 1892405453, 2133024000, 455818693, 2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832);
+            bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (597498209);
+            uint4x3 b2 = uint4x3(367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457, 1395605233, 1191785903, 1156248212, 338891967, 61410415);
+            bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (1576985758);
+            uint4x3 b3 = uint4x3(1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036, 2074160001);
+            bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_not_equal_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786);
+            uint4x3 b0 = uint4x3(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x3 a1 = uint4x3(1909317609, 46519139, 1433204003, 931492669, 670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890);
+            uint4x3 b1 = uint4x3(221862069, 858950046, 989094643, 2023070999, 1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x3 a2 = uint4x3(922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331, 10845678, 1588544505, 709736932, 1892341087);
+            uint4x3 b2 = uint4x3(1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537, 1954996717, 572153302, 865957902, 1083128726);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x3 a3 = uint4x3(1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            uint4x3 b3 = uint4x3(1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_not_equal_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906);
+            uint b0 = (248693828);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x3 a1 = uint4x3(2126300423, 2035077187, 1171827730, 1412347883, 1622176923, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766);
+            uint b1 = (791998981);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x3 a2 = uint4x3(30493685, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847, 1555396158, 913218907, 1739138988, 1916670251, 1516209113);
+            uint b2 = (904014575);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x3 a3 = uint4x3(765258490, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942, 780105497);
+            uint b3 = (668154629);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint4x3 b0 = uint4x3(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (50286949);
+            uint4x3 b1 = uint4x3(2100802631, 1640811853, 82110247, 472172806, 266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720);
+            bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (510966350);
+            uint4x3 b2 = uint4x3(572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338, 676012224, 627370253, 1715733805, 699755913, 1875151666);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (358894860);
+            uint4x3 b3 = uint4x3(1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167, 1002934795);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034);
+            uint4x3 b0 = uint4x3(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105);
+            bool4x3 r0 = bool4x3(false, true, false, false, false, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x3 a1 = uint4x3(1032480172, 1961336172, 923379558, 21210619, 1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162);
+            uint4x3 b1 = uint4x3(684229139, 1234033624, 1278743281, 1953079347, 1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x3 a2 = uint4x3(1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851, 410751553, 198134393, 1999935258, 671192178);
+            uint4x3 b2 = uint4x3(271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203, 833499488, 1999487070, 836063897, 1987309319);
+            bool4x3 r2 = bool4x3(false, false, false, true, false, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x3 a3 = uint4x3(1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            uint4x3 b3 = uint4x3(1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool4x3 r3 = bool4x3(false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650);
+            uint b0 = (1491216667);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x3 a1 = uint4x3(930950514, 933855388, 908563901, 1127696709, 1286331950, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027);
+            uint b1 = (1100560246);
+            bool4x3 r1 = bool4x3(true, true, true, false, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x3 a2 = uint4x3(371987110, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092, 118750042, 1829327996, 452204442, 1645191336, 1829152606);
+            uint b2 = (867559111);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, true, true, false, true, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x3 a3 = uint4x3(1891059504, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493, 212954934);
+            uint b3 = (1217893177);
+            bool4x3 r3 = bool4x3(false, true, true, true, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint4x3 b0 = uint4x3(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311);
+            bool4x3 r0 = bool4x3(false, false, true, true, true, true, false, true, false, true, false, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1890019295);
+            uint4x3 b1 = uint4x3(2098715503, 608933527, 183989010, 1596056507, 1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659);
+            bool4x3 r1 = bool4x3(true, false, false, false, false, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (810406400);
+            uint4x3 b2 = uint4x3(1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204, 1984930954, 743544838, 1473400608, 1300775973, 1351720916);
+            bool4x3 r2 = bool4x3(true, true, false, false, false, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (168788814);
+            uint4x3 b3 = uint4x3(670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033, 685700324);
+            bool4x3 r3 = bool4x3(true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637);
+            uint4x3 b0 = uint4x3(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940);
+            bool4x3 r0 = bool4x3(true, true, false, true, false, true, false, false, true, true, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x3 a1 = uint4x3(180400925, 594688333, 1877031463, 1360073500, 1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622);
+            uint4x3 b1 = uint4x3(641600530, 1830470354, 1570701388, 1104256103, 1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x3 a2 = uint4x3(1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485, 31516321, 1786538920, 1854361210, 1730650972);
+            uint4x3 b2 = uint4x3(335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966, 1782348324, 550490783, 599992449, 550520692);
+            bool4x3 r2 = bool4x3(true, false, false, true, true, false, false, true, false, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x3 a3 = uint4x3(194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            uint4x3 b3 = uint4x3(1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515);
+            uint b0 = (438688675);
+            bool4x3 r0 = bool4x3(true, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x3 a1 = uint4x3(711945018, 577943770, 572743717, 1016617211, 2063134811, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424);
+            uint b1 = (1035679270);
+            bool4x3 r1 = bool4x3(false, false, false, false, true, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x3 a2 = uint4x3(1045140419, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358, 614746280, 1000986708, 1683117650, 1451781409, 61102732);
+            uint b2 = (1058332184);
+            bool4x3 r2 = bool4x3(false, false, true, true, false, false, false, false, false, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x3 a3 = uint4x3(1284938191, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269, 1930086291);
+            uint b3 = (1452639553);
+            bool4x3 r3 = bool4x3(false, true, false, false, true, false, false, false, false, true, false, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint4x3 b0 = uint4x3(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204);
+            bool4x3 r0 = bool4x3(true, true, true, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1556466996);
+            uint4x3 b1 = uint4x3(858599525, 1896917159, 701542098, 1052151621, 1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711);
+            bool4x3 r1 = bool4x3(true, false, true, true, true, true, false, true, true, true, true, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (1713088900);
+            uint4x3 b2 = uint4x3(315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588, 2063431853, 2079035844, 849337819, 1769234051, 358948261);
+            bool4x3 r2 = bool4x3(true, true, true, true, true, true, false, false, false, true, false, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (267985383);
+            uint4x3 b3 = uint4x3(126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217, 1480829811);
+            bool4x3 r3 = bool4x3(true, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_equal_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601);
+            uint4x3 b0 = uint4x3(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981);
+            bool4x3 r0 = bool4x3(false, true, false, true, true, false, false, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x3 a1 = uint4x3(1251092689, 2011681765, 749743684, 183784440, 1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884);
+            uint4x3 b1 = uint4x3(486470891, 1709514236, 2145785285, 854254454, 1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017);
+            bool4x3 r1 = bool4x3(false, false, true, true, true, false, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x3 a2 = uint4x3(912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063, 269897278, 1062947703, 1743454202, 2048964070);
+            uint4x3 b2 = uint4x3(620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397, 648547686, 418431167, 1724009726, 401891826);
+            bool4x3 r2 = bool4x3(false, false, false, false, true, true, true, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x3 a3 = uint4x3(1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            uint4x3 b3 = uint4x3(1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_equal_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763);
+            uint b0 = (1688048545);
+            bool4x3 r0 = bool4x3(false, true, true, true, true, false, true, true, true, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x3 a1 = uint4x3(690091301, 2091514001, 1857173043, 1617221948, 2017733017, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519);
+            uint b1 = (1806172431);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x3 a2 = uint4x3(1917813750, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606, 626254356, 1162369122, 1021674613, 127839058, 1974631244);
+            uint b2 = (1258115260);
+            bool4x3 r2 = bool4x3(false, true, false, true, false, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x3 a3 = uint4x3(426908235, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266, 1483727269);
+            uint b3 = (1818566980);
+            bool4x3 r3 = bool4x3(true, true, true, true, true, false, true, true, false, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint4x3 b0 = uint4x3(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1293698493);
+            uint4x3 b1 = uint4x3(48893340, 66196247, 1958607116, 1576473309, 861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566);
+            bool4x3 r1 = bool4x3(false, false, true, true, false, false, false, false, true, false, false, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (601413850);
+            uint4x3 b2 = uint4x3(830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712, 1556906486, 205552788, 620963188, 1156705971, 1121867260);
+            bool4x3 r2 = bool4x3(true, false, true, true, true, true, true, true, false, true, true, true);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (733876180);
+            uint4x3 b3 = uint4x3(1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410, 1987696011);
+            bool4x3 r3 = bool4x3(true, false, false, true, true, false, false, true, true, true, false, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_equal_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455);
+            uint4x3 b0 = uint4x3(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196);
+            bool4x3 r0 = bool4x3(false, false, true, false, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x3 a1 = uint4x3(1806186947, 1253571980, 589397635, 1951842887, 798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474);
+            uint4x3 b1 = uint4x3(1227300220, 2044269675, 1898323839, 874509380, 1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253);
+            bool4x3 r1 = bool4x3(true, false, false, true, false, false, false, true, false, true, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x3 a2 = uint4x3(605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686, 796452624, 1710612922, 1629927787, 1094198224);
+            uint4x3 b2 = uint4x3(2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792, 802468307, 1090745055, 1968071275, 1935027815);
+            bool4x3 r2 = bool4x3(false, true, true, false, true, true, true, false, false, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x3 a3 = uint4x3(584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            uint4x3 b3 = uint4x3(2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_equal_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867);
+            uint b0 = (1470533736);
+            bool4x3 r0 = bool4x3(true, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x3 a1 = uint4x3(1419295004, 1819986195, 1460027917, 1646290021, 196833647, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862);
+            uint b1 = (471843809);
+            bool4x3 r1 = bool4x3(true, true, true, true, false, true, true, true, true, false, false, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x3 a2 = uint4x3(1449142607, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027, 1138747386, 1491562090, 917503963, 353608194, 1526792895);
+            uint b2 = (1223010129);
+            bool4x3 r2 = bool4x3(true, false, true, false, true, false, false, false, true, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x3 a3 = uint4x3(192092521, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700, 702382564);
+            uint b3 = (909358617);
+            bool4x3 r3 = bool4x3(false, false, true, false, false, true, true, true, true, false, true, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint4x3 b0 = uint4x3(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637);
+            bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, false, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (1214546726);
+            uint4x3 b1 = uint4x3(917376832, 303549425, 2111728811, 945321577, 173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189);
+            bool4x3 r1 = bool4x3(true, true, false, true, true, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (1336522452);
+            uint4x3 b2 = uint4x3(233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727, 337378780, 273010835, 1898553615, 1111540136, 717385513);
+            bool4x3 r2 = bool4x3(true, true, true, true, false, true, true, true, true, false, true, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (474197678);
+            uint4x3 b3 = uint4x3(1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168, 1274079907);
+            bool4x3 r3 = bool4x3(false, false, false, true, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_add_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303);
+            uint4x3 b0 = uint4x3(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357);
+            uint4x3 r0 = uint4x3(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161, 2285462935, 1101613923, 3495777492, 1384643660);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x3 a1 = uint4x3(2103582820, 526139155, 447937230, 2127411006, 1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366);
+            uint4x3 b1 = uint4x3(2043773873, 223363428, 175115707, 985928617, 507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905);
+            uint4x3 r1 = uint4x3(4147356693, 749502583, 623052937, 3113339623, 2178242226, 3146426160, 1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x3 a2 = uint4x3(941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688, 526120638, 423980484, 1867227242, 603782684);
+            uint4x3 b2 = uint4x3(2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603, 77965941, 1726775513, 1759186349, 2070333485);
+            uint4x3 r2 = uint4x3(3048865720, 2901392143, 1940611170, 1099044556, 2362767916, 1285092016, 2641863205, 3757383291, 604086579, 2150755997, 3626413591, 2674116169);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x3 a3 = uint4x3(728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            uint4x3 b3 = uint4x3(1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            uint4x3 r3 = uint4x3(2461211795, 1450246522, 2444787499, 1669976746, 3356749404, 1917402232, 1548618217, 2863380484, 3471071068, 2013864506, 348877644, 2242427741);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_add_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202);
+            uint b0 = (2124409227);
+            uint4x3 r0 = uint4x3(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528, 4127431088, 3760381198, 3284807513, 2209855429);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x3 a1 = uint4x3(1068152966, 1497676888, 1727477485, 1095438654, 756559204, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233);
+            uint b1 = (1239387100);
+            uint4x3 r1 = uint4x3(2307540066, 2737063988, 2966864585, 2334825754, 1995946304, 3058106031, 1898310652, 2849906021, 2825142498, 1932230400, 2307980569, 2944163333);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x3 a2 = uint4x3(577782260, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263, 656748782, 272774516, 1917133199, 828322973, 2116810190);
+            uint b2 = (736972565);
+            uint4x3 r2 = uint4x3(1314754825, 1448867136, 1301230004, 2788708848, 2309810262, 2364979110, 2592672828, 1393721347, 1009747081, 2654105764, 1565295538, 2853782755);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x3 a3 = uint4x3(2092767444, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914, 1340503111);
+            uint b3 = (973587865);
+            uint4x3 r3 = uint4x3(3066355309, 2210519138, 1477852314, 1767880439, 2491646546, 2578224189, 1328461282, 1658835762, 1201369005, 1294770382, 2184163779, 2314090976);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint4x3 b0 = uint4x3(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302);
+            uint4x3 r0 = uint4x3(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150, 1387123903, 1948867027, 1170867018, 1502633380);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (783046445);
+            uint4x3 b1 = uint4x3(1130163944, 288279584, 1397683861, 1636583489, 673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768);
+            uint4x3 r1 = uint4x3(1913210389, 1071326029, 2180730306, 2419629934, 1456309784, 2252347319, 797902410, 1899683444, 2271909745, 2384037331, 973697746, 2090506213);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (920085839);
+            uint4x3 b2 = uint4x3(2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640, 1806146508, 1841791222, 206610851, 526971953, 1236359886);
+            uint4x3 r2 = uint4x3(3002315674, 2912491413, 2134010297, 1425927291, 1901507001, 2408423538, 2033912479, 2726232347, 2761877061, 1126696690, 1447057792, 2156445725);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1459523189);
+            uint4x3 b3 = uint4x3(965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031, 1275565021);
+            uint4x3 r3 = uint4x3(2425263820, 1542365988, 2757926390, 3265332961, 3438387380, 1874526575, 3365827337, 2182393386, 2203771985, 3136746748, 1762899220, 2735088210);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_sub_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081);
+            uint4x3 b0 = uint4x3(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395);
+            uint4x3 r0 = uint4x3(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549, 1234495882, 3456019244, 3562788131, 3413504982);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x3 a1 = uint4x3(86359575, 1049709943, 721529513, 1767221271, 7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454);
+            uint4x3 b1 = uint4x3(136565478, 1979903295, 600719425, 837912956, 632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855);
+            uint4x3 r1 = uint4x3(4244761393, 3364773944, 120810088, 929308315, 3670565287, 4129068219, 3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x3 a2 = uint4x3(425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176, 1888446703, 1364654917, 265135366, 760501098);
+            uint4x3 b2 = uint4x3(609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694, 1224986479, 748933681, 88793450, 401362529);
+            uint4x3 r2 = uint4x3(4111227161, 972642792, 3745373142, 2826807304, 3564332942, 1218011798, 1846728662, 3739059778, 663460224, 615721236, 176341916, 359138569);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x3 a3 = uint4x3(741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            uint4x3 b3 = uint4x3(1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            uint4x3 r3 = uint4x3(3949049757, 1650323877, 979082147, 182559134, 4158572232, 1442113917, 8339009, 1379854326, 3702505823, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_sub_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336);
+            uint b0 = (462232403);
+            uint4x3 r0 = uint4x3(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412, 4113909093, 3920265733, 1451492028, 1579360933);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x3 a1 = uint4x3(557239990, 1590376732, 819090189, 816382635, 815920639, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742);
+            uint b1 = (1119051448);
+            uint4x3 r1 = uint4x3(3733155838, 471325284, 3995006037, 3992298483, 3991836487, 709981669, 673750484, 4289356397, 299886528, 158205741, 973727950, 3818152590);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x3 a2 = uint4x3(1605250794, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758, 1817991764, 1280985500, 676974855, 1638032613, 949761204);
+            uint b2 = (819644478);
+            uint4x3 r2 = uint4x3(785606316, 648358541, 3603626004, 4028817075, 197482493, 1180100304, 1197628280, 998347286, 461341022, 4152297673, 818388135, 130116726);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x3 a3 = uint4x3(1835969317, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965, 941598524);
+            uint b3 = (919015590);
+            uint4x3 r3 = uint4x3(916953727, 57931720, 385231016, 537764618, 635007122, 4145756071, 1138816097, 4134088285, 4046384961, 3979183117, 754253375, 22582934);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint4x3 b0 = uint4x3(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748);
+            uint4x3 r0 = uint4x3(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128, 4197201280, 1426821512, 459678338, 4168388953);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (1428436109);
+            uint4x3 b1 = uint4x3(1258745460, 1077380396, 1330722719, 518111829, 967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461);
+            uint4x3 r1 = uint4x3(169690649, 351055713, 97713390, 910324280, 461307580, 1083769855, 346168191, 520569413, 3906518282, 968095541, 466281611, 871322648);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (1701216709);
+            uint4x3 b2 = uint4x3(1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530, 506757390, 1216448041, 936312747, 1997286455, 1969982026);
+            uint4x3 r2 = uint4x3(4016085228, 971156157, 256818882, 847646153, 1562380277, 688026281, 983127179, 1194459319, 484768668, 764903962, 3998897550, 4026201979);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (902880656);
+            uint4x3 b3 = uint4x3(1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072, 2066839749);
+            uint4x3 r3 = uint4x3(4036627255, 3755383227, 279919891, 171911747, 288056815, 3308068932, 4279525600, 768950736, 689757548, 3362397492, 381812584, 3131008203);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mul_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734);
+            uint4x3 b0 = uint4x3(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155);
+            uint4x3 r0 = uint4x3(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228, 2640799263, 2093463192, 3087460678, 3161406466);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x3 a1 = uint4x3(2055121568, 700402816, 263414349, 187830569, 2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234);
+            uint4x3 b1 = uint4x3(1460605791, 1968043860, 771161742, 2037340417, 322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952);
+            uint4x3 r1 = uint4x3(990589280, 3356793344, 2953243830, 1156600361, 649177976, 678952165, 1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x3 a2 = uint4x3(899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666, 200879709, 857149632, 962693646, 988118613);
+            uint4x3 b2 = uint4x3(675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297, 1695925670, 1788874462, 534570710, 1110638325);
+            uint4x3 r2 = uint4x3(1891467339, 335415735, 1128927428, 2638713520, 2861115658, 479369680, 3928339236, 4044803354, 48406862, 2297104000, 4019846068, 2811510105);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x3 a3 = uint4x3(892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            uint4x3 b3 = uint4x3(142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            uint4x3 r3 = uint4x3(293009766, 3677102970, 1179445736, 3813187164, 2708838392, 1397450915, 487571412, 3889286542, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mul_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747);
+            uint b0 = (1476837906);
+            uint4x3 r0 = uint4x3(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778, 1736252960, 2595843622, 2760103458, 2441439286);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x3 a1 = uint4x3(1818877398, 660611671, 1279757657, 391009467, 1186856590, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300);
+            uint b1 = (1324050764);
+            uint4x3 r1 = uint4x3(1927061896, 645718228, 3706353516, 3450526340, 3727282216, 2610351864, 3202713768, 133057916, 2712818352, 3265005844, 4046133608, 100822256);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x3 a2 = uint4x3(1192501703, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062, 987919119, 1659987051, 1325430351, 948943118, 1743760648);
+            uint b2 = (1613845584);
+            uint4x3 r2 = uint4x3(3900103216, 2959506480, 692371456, 973833232, 1630959136, 2616598816, 4103626336, 1516495024, 2027781488, 471196848, 2169531488, 1043640960);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x3 a3 = uint4x3(227492421, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790, 396984449);
+            uint b3 = (217698851);
+            uint4x3 r3 = uint4x3(269461871, 1120555251, 1293383984, 1838219542, 3023271884, 1677010101, 1900394426, 512258290, 4056397088, 3786096410, 1697920914, 1359963043);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint4x3 b0 = uint4x3(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767);
+            uint4x3 r0 = uint4x3(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328, 1623617844, 2603413056, 3464455056, 3011267876);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (243286231);
+            uint4x3 b1 = uint4x3(1336308795, 517963367, 1733623488, 459880225, 994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639);
+            uint4x3 r1 = uint4x3(3646578061, 2731337857, 3893490496, 2980416695, 62369507, 4218409817, 2881159196, 3966864259, 2038656731, 2224055319, 2818606435, 2745388689);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (1323243330);
+            uint4x3 b2 = uint4x3(1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281, 2138825098, 1273008873, 1788343477, 1994364082, 597340263);
+            uint4x3 r2 = uint4x3(4200942488, 50866050, 1979584376, 2165828294, 2084048518, 3664351394, 1987582754, 2187955092, 3020934930, 1909741994, 2131645412, 527678350);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (2022856151);
+            uint4x3 b3 = uint4x3(1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370, 890235481);
+            uint4x3 r3 = uint4x3(2359761627, 3607975719, 2368172860, 3241673466, 3640972603, 2445305544, 1198448575, 3108682444, 2733658999, 2364617365, 3384645854, 938433983);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_div_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242);
+            uint4x3 b0 = uint4x3(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518);
+            uint4x3 r0 = uint4x3(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x3 a1 = uint4x3(788249865, 1099825433, 1552968283, 1822367139, 1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343);
+            uint4x3 b1 = uint4x3(1906634983, 437754923, 825037958, 902508708, 896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844);
+            uint4x3 r1 = uint4x3(0, 2, 1, 2, 1, 39, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x3 a2 = uint4x3(1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291, 850951883, 1942618200, 1088675276, 1648515976);
+            uint4x3 b2 = uint4x3(616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550, 1535651093, 932740870, 1078416711, 725172174);
+            uint4x3 r2 = uint4x3(2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x3 a3 = uint4x3(991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            uint4x3 b3 = uint4x3(554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            uint4x3 r3 = uint4x3(1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_div_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657);
+            uint b0 = (947861580);
+            uint4x3 r0 = uint4x3(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x3 a1 = uint4x3(2131487088, 1017891310, 542666029, 1646044372, 1447236569, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885);
+            uint b1 = (2105094094);
+            uint4x3 r1 = uint4x3(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x3 a2 = uint4x3(1919705924, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156, 1725332114, 1949103348, 1383839785, 2136282541, 159847918);
+            uint b2 = (1244966864);
+            uint4x3 r2 = uint4x3(1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x3 a3 = uint4x3(1515555001, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647, 1222061694);
+            uint b3 = (614923813);
+            uint4x3 r3 = uint4x3(2, 1, 3, 3, 3, 1, 3, 0, 0, 2, 3, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint4x3 b0 = uint4x3(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703);
+            uint4x3 r0 = uint4x3(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (631027637);
+            uint4x3 b1 = uint4x3(396671391, 784365696, 1250594097, 1818363859, 1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043);
+            uint4x3 r1 = uint4x3(1, 0, 0, 0, 0, 2, 12, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (1054404890);
+            uint4x3 b2 = uint4x3(351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309, 2114509003, 1266146708, 45105265, 2092444751, 407744534);
+            uint4x3 r2 = uint4x3(2, 7, 0, 2, 0, 4, 0, 0, 0, 23, 0, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (126616016);
+            uint4x3 b3 = uint4x3(1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719, 638134699);
+            uint4x3 r3 = uint4x3(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mod_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173);
+            uint4x3 b0 = uint4x3(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956);
+            uint4x3 r0 = uint4x3(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x3 a1 = uint4x3(938026607, 1692541775, 1518877124, 1806965510, 1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189);
+            uint4x3 b1 = uint4x3(160166322, 1099108075, 1158422232, 1798905209, 164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748);
+            uint4x3 r1 = uint4x3(137194997, 593433700, 360454892, 8060301, 7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x3 a2 = uint4x3(1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277, 1090018756, 1573062648, 1100694500, 863521889);
+            uint4x3 b2 = uint4x3(798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990, 1350943898, 696511738, 1182727748, 1843845940);
+            uint4x3 r2 = uint4x3(604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277, 1090018756, 180039172, 1100694500, 863521889);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x3 a3 = uint4x3(1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            uint4x3 b3 = uint4x3(244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            uint4x3 r3 = uint4x3(166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mod_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935);
+            uint b0 = (883951171);
+            uint4x3 r0 = uint4x3(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x3 a1 = uint4x3(712321026, 1540068445, 1085897743, 1607489717, 165478511, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912);
+            uint b1 = (172564850);
+            uint4x3 r1 = uint4x3(22061626, 159549645, 50508643, 54406067, 165478511, 130152166, 52883749, 49746751, 65367033, 49545706, 143379989, 17042712);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x3 a2 = uint4x3(377501313, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470, 1568090825, 2050982942, 435886407, 453990946, 1731665372);
+            uint b2 = (1778384846);
+            uint4x3 r2 = uint4x3(377501313, 1216011754, 812183417, 1153802502, 1642671870, 146325896, 665297470, 1568090825, 272598096, 435886407, 453990946, 1731665372);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x3 a3 = uint4x3(586777590, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411, 1524342239);
+            uint b3 = (1475597526);
+            uint4x3 r3 = uint4x3(586777590, 110051989, 1414579860, 416067455, 1262495021, 1400758118, 53934482, 430295164, 1386414018, 654749032, 666621411, 48744713);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint4x3 b0 = uint4x3(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233);
+            uint4x3 r0 = uint4x3(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1298102643);
+            uint4x3 b1 = uint4x3(2057984657, 1000742091, 1461372131, 1859742342, 797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738);
+            uint4x3 r1 = uint4x3(1298102643, 297360552, 1298102643, 1298102643, 500917956, 476213801, 214909646, 457987657, 1298102643, 67782715, 1298102643, 1739061);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (2122220318);
+            uint4x3 b2 = uint4x3(164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388, 1477846418, 511428733, 1642227542, 1962310765, 207128894);
+            uint4x3 r2 = uint4x3(147283586, 662044080, 677274179, 816428281, 1011391307, 376773156, 120051662, 644373900, 76505386, 479992776, 159909553, 50931378);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1342085447);
+            uint4x3 b3 = uint4x3(448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751, 1648646354);
+            uint4x3 r3 = uint4x3(445362875, 3415371, 636619696, 588996674, 195741437, 241524871, 267605306, 1342085447, 1342085447, 1342085447, 243643696, 1342085447);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_plus()
+        {
+            uint4x3 a0 = uint4x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            uint4x3 r0 = uint4x3(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint4x3 a1 = uint4x3(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            uint4x3 r1 = uint4x3(1864850812, 1145639744, 1615499926, 2049663954, 1723005749, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint4x3 a2 = uint4x3(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            uint4x3 r2 = uint4x3(308695413, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393, 829347661, 33442669, 381670450, 277507230, 361395485);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint4x3 a3 = uint4x3(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            uint4x3 r3 = uint4x3(1012749225, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986, 1257555634);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_neg()
+        {
+            uint4x3 a0 = uint4x3(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286);
+            uint4x3 r0 = uint4x3(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947, 3179939058, 2658692327, 3599972203, 2752761010);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint4x3 a1 = uint4x3(213087293, 341522275, 841085242, 574159094, 1687250035, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864);
+            uint4x3 r1 = uint4x3(4081880003, 3953445021, 3453882054, 3720808202, 2607717261, 2237047603, 3119952564, 3035158223, 3082501970, 3104397376, 2247011524, 2174237432);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint4x3 a2 = uint4x3(1440774928, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284, 1954173314, 1709857098, 1836511050, 1662806453, 506144868);
+            uint4x3 r2 = uint4x3(2854192368, 3863301205, 2907365578, 2549315298, 3975851670, 3175007490, 3555835012, 2340793982, 2585110198, 2458456246, 2632160843, 3788822428);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint4x3 a3 = uint4x3(650922971, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551, 1768435578);
+            uint4x3 r3 = uint4x3(3644044325, 3020970047, 2820522109, 2441140349, 2599393523, 3565514784, 3949897936, 3719099760, 3700848258, 3093126687, 2952094745, 2526531718);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_prefix_inc()
+        {
+            uint4x3 a0 = uint4x3(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935);
+            uint4x3 r0 = uint4x3(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint4x3 a1 = uint4x3(1835605516, 388229350, 696475402, 1786514683, 993189311, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489);
+            uint4x3 r1 = uint4x3(1835605517, 388229351, 696475403, 1786514684, 993189312, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint4x3 a2 = uint4x3(504806865, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661, 65514038, 1495168208, 1321109497, 1366348660, 1777734111);
+            uint4x3 r2 = uint4x3(504806866, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662, 65514039, 1495168209, 1321109498, 1366348661, 1777734112);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint4x3 a3 = uint4x3(1414867743, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802, 413165245);
+            uint4x3 r3 = uint4x3(1414867744, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803, 413165246);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_postfix_inc()
+        {
+            uint4x3 a0 = uint4x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            uint4x3 r0 = uint4x3(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint4x3 a1 = uint4x3(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            uint4x3 r1 = uint4x3(1408994706, 1580130369, 1676086778, 717006530, 506142468, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint4x3 a2 = uint4x3(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            uint4x3 r2 = uint4x3(357567451, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403, 1919960927, 840371710, 2010345998, 1047836590, 586887730);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint4x3 a3 = uint4x3(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            uint4x3 r3 = uint4x3(1209169651, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320, 1995020676);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_prefix_dec()
+        {
+            uint4x3 a0 = uint4x3(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358);
+            uint4x3 r0 = uint4x3(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint4x3 a1 = uint4x3(1914114460, 389120307, 1022184392, 1310293956, 356565557, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297);
+            uint4x3 r1 = uint4x3(1914114459, 389120306, 1022184391, 1310293955, 356565556, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint4x3 a2 = uint4x3(220897829, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100, 157482354, 965385343, 1797304434, 1083672612, 929765380);
+            uint4x3 r2 = uint4x3(220897828, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099, 157482353, 965385342, 1797304433, 1083672611, 929765379);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint4x3 a3 = uint4x3(2083512379, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317, 767990877);
+            uint4x3 r3 = uint4x3(2083512378, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316, 767990876);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_postfix_dec()
+        {
+            uint4x3 a0 = uint4x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            uint4x3 r0 = uint4x3(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint4x3 a1 = uint4x3(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            uint4x3 r1 = uint4x3(526366486, 590919177, 60677868, 1867810045, 2095777993, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint4x3 a2 = uint4x3(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            uint4x3 r2 = uint4x3(1868889881, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911, 416440036, 1447690298, 1444496274, 296146626, 1209855130);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint4x3 a3 = uint4x3(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            uint4x3 r3 = uint4x3(2016700604, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298, 569144612);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_and_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564);
+            uint4x3 b0 = uint4x3(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027);
+            uint4x3 r0 = uint4x3(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x3 a1 = uint4x3(233435438, 665207770, 1942050241, 1022352952, 60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372);
+            uint4x3 b1 = uint4x3(1900854122, 413173763, 1409138251, 2087190272, 563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586);
+            uint4x3 r1 = uint4x3(21541162, 10485762, 1405162561, 1013440000, 26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x3 a2 = uint4x3(181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014, 1804502415, 1733695477, 1110712857, 113012430);
+            uint4x3 b2 = uint4x3(1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314, 843085933, 1045118223, 41867329, 1397669260);
+            uint4x3 r2 = uint4x3(177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602, 570425357, 641864965, 36962305, 34352268);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x3 a3 = uint4x3(1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            uint4x3 b3 = uint4x3(1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            uint4x3 r3 = uint4x3(706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_and_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920);
+            uint b0 = (93423598);
+            uint4x3 r0 = uint4x3(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x3 a1 = uint4x3(1249238550, 1862276471, 143502472, 861733033, 1408932942, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025);
+            uint b1 = (814629680);
+            uint4x3 r1 = uint4x3(279056, 536871216, 9175040, 806092832, 277479424, 805568528, 268452112, 9175824, 268567088, 268697600, 934144, 8650784);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x3 a2 = uint4x3(462670926, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772, 872875431, 1143080525, 708719245, 1764446048, 1527981061);
+            uint b2 = (1817145060);
+            uint4x3 r2 = uint4x3(134433860, 1145858724, 1816224836, 542076516, 739126372, 1611530816, 537593028, 604439716, 1140983364, 672014980, 1745571424, 1208165380);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x3 a3 = uint4x3(398141788, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172, 1826788967);
+            uint b3 = (156911041);
+            uint4x3 r3 = uint4x3(18481472, 17843457, 5783937, 156763393, 22151233, 138937729, 152585345, 4867329, 21643264, 132544, 4719616, 138544193);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint4x3 b0 = uint4x3(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596);
+            uint4x3 r0 = uint4x3(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1763483957);
+            uint4x3 b1 = uint4x3(1248975349, 236938635, 185023291, 1085233038, 1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366);
+            uint4x3 r1 = uint4x3(1209041205, 136061185, 151265585, 1074528516, 1744830512, 671121697, 1092091952, 1761607941, 18391060, 1761615904, 1763221553, 1091051540);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (1233066417);
+            uint4x3 b2 = uint4x3(1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851, 372814411, 1623486506, 211665304, 1668985777, 348112007);
+            uint4x3 r2 = uint4x3(1214058640, 2230321, 1210847617, 1074401680, 1211367456, 1116577, 1232603553, 3674113, 1078202400, 136118672, 1098518961, 4128897);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1808619374);
+            uint4x3 b3 = uint4x3(1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681, 1980296380);
+            uint4x3 r3 = uint4x3(1246058336, 1644778764, 12650346, 1640318254, 1216610624, 587220044, 1644695918, 33834028, 734795298, 671961678, 1241777216, 1644708908);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_or_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137);
+            uint4x3 b0 = uint4x3(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879);
+            uint4x3 r0 = uint4x3(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x3 a1 = uint4x3(330307355, 818676817, 1774459567, 1117506257, 1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074);
+            uint4x3 b1 = uint4x3(1502255628, 1841676448, 1682928938, 1115131952, 1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841);
+            uint4x3 r1 = uint4x3(1538957087, 2110637297, 1842315183, 1124063985, 1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x3 a2 = uint4x3(543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210, 203868172, 32846030, 1057901177, 1537975433);
+            uint4x3 b2 = uint4x3(108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147, 2036352209, 1554561114, 1332339254, 480739851);
+            uint4x3 r2 = uint4x3(645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587, 2103889117, 1576909022, 2138040959, 1605346955);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x3 a3 = uint4x3(470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            uint4x3 b3 = uint4x3(1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            uint4x3 r3 = uint4x3(1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_or_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856);
+            uint b0 = (1666102508);
+            uint4x3 r0 = uint4x3(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x3 a1 = uint4x3(879300408, 797240690, 1977614655, 46921989, 1980838747, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070);
+            uint b1 = (1179087439);
+            uint4x3 r1 = uint4x3(1987018623, 1875378047, 2011657087, 1188035407, 1985442655, 1459090271, 1205302255, 1459058687, 1465382751, 1995407311, 1599567599, 2122316799);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x3 a2 = uint4x3(2055963359, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015, 539526284, 310877895, 1815369493, 529427586, 358352200);
+            uint b2 = (1511253082);
+            uint4x3 r2 = uint4x3(2057037535, 2077750875, 1579155451, 2069362559, 1590951034, 1534850271, 1593306847, 2050745566, 1519910623, 2117597023, 1604316378, 1600120154);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x3 a3 = uint4x3(1353013374, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643, 142082352);
+            uint b3 = (1349149982);
+            uint4x3 r3 = uint4x3(1357872510, 1895528286, 1374318015, 2012964638, 1550483390, 1602123263, 1483666815, 1920624063, 1458464191, 2012116286, 1424685023, 1484416318);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint4x3 b0 = uint4x3(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649);
+            uint4x3 r0 = uint4x3(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (1059093741);
+            uint4x3 b1 = uint4x3(627815046, 418822515, 83214352, 424663473, 447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329);
+            uint4x3 r1 = uint4x3(1064042223, 1073151487, 1073085693, 1064304125, 1068727789, 1063910895, 2133818605, 1060240621, 2145910509, 2138209533, 2146074365, 2142830317);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (1088734150);
+            uint4x3 b2 = uint4x3(298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560, 990961386, 547309556, 1307122961, 263229121, 1518227598);
+            uint4x3 r2 = uint4x3(1374682086, 2063067087, 1660812255, 1743570934, 1945042926, 1089859558, 1911943150, 2079645678, 1627375606, 1307434967, 1341444039, 1526649806);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (1098359242);
+            uint4x3 b3 = uint4x3(997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616, 1326199854);
+            uint4x3 r3 = uint4x3(2071978954, 1098885598, 2071455727, 1702356954, 1098381823, 1568651246, 2046802926, 1509946863, 2038414794, 1644161007, 1308081658, 1333769710);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_xor_wide_wide()
+        {
+            uint4x3 a0 = uint4x3(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188);
+            uint4x3 b0 = uint4x3(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641);
+            uint4x3 r0 = uint4x3(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x3 a1 = uint4x3(700973621, 370621508, 2087573076, 351476570, 1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405);
+            uint4x3 b1 = uint4x3(1040688781, 1020757245, 1143954843, 1281933464, 175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483);
+            uint4x3 r1 = uint4x3(399484088, 717273273, 943885263, 1486609346, 1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x3 a2 = uint4x3(1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968, 32554542, 1915830925, 2001025156, 2012451132);
+            uint4x3 b2 = uint4x3(1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491, 325882121, 45335181, 1859278043, 1002624300);
+            uint4x3 r2 = uint4x3(981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459, 312225575, 1887600640, 429354079, 1278297104);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x3 a3 = uint4x3(1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            uint4x3 b3 = uint4x3(1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            uint4x3 r3 = uint4x3(632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_xor_wide_scalar()
+        {
+            uint4x3 a0 = uint4x3(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267);
+            uint b0 = (493665894);
+            uint4x3 r0 = uint4x3(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x3 a1 = uint4x3(125659640, 1730088797, 116862046, 375757978, 491079274, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924);
+            uint b1 = (1315625690);
+            uint4x3 r1 = uint4x3(1226289954, 695588231, 1218311812, 1477396032, 1395629232, 1158101236, 1162708111, 2010043079, 1856848613, 1753692570, 1315361570, 373338582);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x3 a2 = uint4x3(1680011736, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973, 1059509471, 744733291, 64097148, 1814786305, 716239);
+            uint b2 = (447453839);
+            uint4x3 r2 = uint4x3(2122935127, 800240497, 198659571, 98559616, 86185743, 1221222109, 1565485394, 630017616, 919085284, 427397619, 1988160398, 446789440);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x3 a3 = uint4x3(476052372, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185, 1771744425);
+            uint b3 = (92561487);
+            uint4x3 r3 = uint4x3(433822683, 2133436125, 133297725, 1274987888, 2020970994, 180462097, 52620731, 1114759625, 2024733453, 2005017615, 912470822, 1813957862);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint4x3 b0 = uint4x3(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424);
+            uint4x3 r0 = uint4x3(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (1947871003);
+            uint4x3 b1 = uint4x3(1774252400, 1946113778, 1079717492, 290620937, 1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881);
+            uint4x3 r1 = uint4x3(500881003, 132477417, 876677487, 1699258642, 645842392, 1138923504, 974408494, 2033457704, 1087830061, 1348553799, 2139822446, 660194722);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (573581481);
+            uint4x3 b2 = uint4x3(1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943, 714832744, 374210759, 215701593, 1573378082, 779254615);
+            uint4x3 r2 = uint4x3(1311539225, 655981444, 1435501080, 2003229500, 399194716, 2022579220, 693043286, 145445825, 880683118, 787181808, 2146955403, 205673470);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (711527976);
+            uint4x3 b3 = uint4x3(710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645, 896851285);
+            uint4x3 r3 = uint4x3(3284335, 658000982, 154339351, 2085169939, 946304861, 44451568, 2115414221, 2137251591, 317021346, 552683235, 1575100285, 522048381);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_left_shift()
+        {
+            uint4x3 a0 = uint4x3(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534);
+            int b0 = (1321149625);
+            uint4x3 r0 = uint4x3(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832, 2885681152, 838860800, 3422552064, 2885681152);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint4x3 a1 = uint4x3(1447702302, 35667343, 1664454606, 2045594989, 2077023268, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181);
+            int b1 = (1079614371);
+            uint4x3 r1 = uint4x3(2991683824, 285338744, 430734960, 3479858024, 3731284256, 446462192, 2382043288, 897198008, 703071480, 298127560, 3687382248, 3583706856);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint4x3 a2 = uint4x3(263886278, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875, 1824729613, 1535276688, 1581610518, 407677878, 1208958192);
+            int b2 = (221147365);
+            uint4x3 r2 = uint4x3(4149393600, 2269589216, 3094178816, 2284910336, 2519121408, 3273503744, 1296563040, 2556772768, 1884213760, 3366896320, 160790208, 31956480);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint4x3 a3 = uint4x3(740058147, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326, 1996060114);
+            int b3 = (946058001);
+            uint4x3 r3 = uint4x3(3360030720, 4207017984, 1441398784, 3029598208, 4289593344, 2718695424, 3680632832, 1110573056, 1163132928, 173408256, 1445724160, 3953393664);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_right_shift()
+        {
+            uint4x3 a0 = uint4x3(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045);
+            int b0 = (1266801540);
+            uint4x3 r0 = uint4x3(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint4x3 a1 = uint4x3(701927980, 569504877, 185593382, 1102123711, 334005460, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762);
+            int b1 = (917785020);
+            uint4x3 r1 = uint4x3(2, 2, 0, 4, 1, 6, 1, 5, 6, 2, 4, 1);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint4x3 a2 = uint4x3(763607760, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389, 352174824, 1164508476, 425441430, 186542511, 1099859381);
+            int b2 = (348013684);
+            uint4x3 r2 = uint4x3(728, 1495, 738, 1513, 572, 28, 1793, 335, 1110, 405, 177, 1048);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint4x3 a3 = uint4x3(1234295294, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981, 1435331003);
+            int b3 = (1028666766);
+            uint4x3 r3 = uint4x3(75335, 46488, 76590, 55139, 72040, 11168, 58514, 65650, 86028, 96236, 42779, 87605);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x3_operator_bitwise_not()
+        {
+            uint4x3 a0 = uint4x3(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024);
+            uint4x3 r0 = uint4x3(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439, 3822001804, 3523255869, 3667386335, 2233443271);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint4x3 a1 = uint4x3(753208488, 1303022493, 664744603, 1289372466, 1635981125, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321);
+            uint4x3 r1 = uint4x3(3541758807, 2991944802, 3630222692, 3005594829, 2658986170, 2343948699, 2749315358, 3577030838, 3010462608, 2952181910, 3425337820, 2249112974);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint4x3 a2 = uint4x3(1282546942, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274, 695179852, 1766938039, 897923626, 1816190464, 1362906829);
+            uint4x3 r2 = uint4x3(3012420353, 2470142485, 2558396580, 3786061237, 2234214415, 2427548539, 3906437021, 3599787443, 2528029256, 3397043669, 2478776831, 2932060466);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint4x3 a3 = uint4x3(1227946838, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010, 722020848);
+            uint4x3 r3 = uint4x3(3067020457, 4105358017, 3338525487, 2171478485, 2701953044, 4275744234, 2572859341, 2658091601, 2380869903, 2912422268, 3009690285, 3572946447);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..4c46c9277f632548daf9075fe8c7e8c690e7ec89
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x3.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2459d4a10dea40e469cb5f05b3fa80c2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs
new file mode 100644
index 0000000000000000000000000000000000000000..13b277375d8a7f178908fd01240556681693efb0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs
@@ -0,0 +1,1258 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestUint4x4
+    {
+        [TestCompiler]
+        public static void uint4x4_zero()
+        {
+            TestUtils.AreEqual(uint4x4.zero.c0.x, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c0.y, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c0.z, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c0.w, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c1.x, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c1.y, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c1.z, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c1.w, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c2.x, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c2.y, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c2.z, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c2.w, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c3.x, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c3.y, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c3.z, 0u);
+            TestUtils.AreEqual(uint4x4.zero.c3.w, 0u);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_identity()
+        {
+            TestUtils.AreEqual(uint4x4.identity.c0.x, 1u);
+            TestUtils.AreEqual(uint4x4.identity.c0.y, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c0.z, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c0.w, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c1.x, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c1.y, 1u);
+            TestUtils.AreEqual(uint4x4.identity.c1.z, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c1.w, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c2.x, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c2.y, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c2.z, 1u);
+            TestUtils.AreEqual(uint4x4.identity.c2.w, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c3.x, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c3.y, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c3.z, 0u);
+            TestUtils.AreEqual(uint4x4.identity.c3.w, 1u);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_equal_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(790229414, 970783976, 1428432738, 1578747135, 1733797753, 2001507228, 1446876437, 1777406370, 1426387268, 1809275021, 1843770816, 1172185222, 1469608940, 869874758, 458603090, 581282460);
+            uint4x4 b0 = uint4x4(612337669, 1214209108, 2120643427, 295461214, 1510890331, 1893316566, 921816149, 1834958575, 1482011863, 2062852792, 226398742, 770290735, 36812057, 543224481, 1565350150, 1909926604);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x4 a1 = uint4x4(1948324909, 1129078206, 1638391029, 1135553683, 2079295200, 576232476, 608208235, 11172509, 1025529486, 2095601864, 193500113, 1780908384, 1587636094, 1892083815, 1250768669, 1984341771);
+            uint4x4 b1 = uint4x4(1619900436, 1849990483, 1261604411, 161864811, 843379453, 1780425458, 215681636, 2123130580, 708665810, 1902328998, 1808456602, 563830672, 200493241, 1391620681, 1035522654, 168447603);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x4 a2 = uint4x4(929607871, 2092475304, 1940221590, 196567546, 346458180, 2131041239, 1797649913, 162082500, 25639548, 1665178642, 1617231933, 1716426491, 1986475699, 262354389, 1517004243, 1058579789);
+            uint4x4 b2 = uint4x4(91580624, 1974459648, 2074899534, 164782857, 1647410210, 1000391363, 1539243411, 1253927304, 894227825, 1897420927, 826437109, 139868307, 565247534, 1437897788, 1891416649, 1043772546);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x4 a3 = uint4x4(1006521329, 850817587, 270689979, 182908990, 512098264, 1555870818, 1824899010, 913664406, 38410741, 1365981133, 1517827659, 698699317, 522637780, 2135467596, 1812545145, 795262261);
+            uint4x4 b3 = uint4x4(407784873, 516627611, 184196508, 1098113599, 1930819007, 693573550, 780517021, 48392683, 638156511, 356540844, 86920844, 103170762, 1952606997, 1374974056, 906153405, 602525178);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_equal_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(1211464300, 1921862607, 508076684, 1249127920, 1394594555, 746862310, 1733655277, 1884008277, 1682018538, 795585660, 936027116, 927605411, 672785749, 1465584610, 585324157, 404448210);
+            uint b0 = (746972502);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint4x4 a1 = uint4x4(969511077, 1772925698, 1884034177, 451512860, 425476075, 1370577708, 597010220, 1249636005, 211986678, 1305479811, 255635293, 1150443719, 177122433, 511346787, 1442445694, 667984966);
+            uint b1 = (442746747);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint4x4 a2 = uint4x4(1684122010, 172230876, 496695881, 955604291, 872759249, 811880239, 1604334190, 443527663, 1734064824, 1483978726, 1018945528, 476526026, 564821616, 1368099334, 2134154866, 2136028886);
+            uint b2 = (1962874832);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint4x4 a3 = uint4x4(20195989, 1256964339, 165389004, 759951440, 321496427, 551284899, 2058550111, 2146975562, 1182607877, 1588866146, 1478019984, 733564558, 1504896105, 284238873, 1641065069, 259620445);
+            uint b3 = (550465422);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_equal_scalar_wide()
+        {
+            uint a0 = (1150044438);
+            uint4x4 b0 = uint4x4(233855098, 924242519, 1402948791, 601381975, 2120518068, 629187703, 1971977031, 47183124, 1061805787, 1009011238, 312511148, 1460673064, 737210539, 1737844479, 1892405453, 2133024000);
+            bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a0 == b0, r0);
+
+            uint a1 = (455818693);
+            uint4x4 b1 = uint4x4(2003197687, 1276241219, 534746610, 559824292, 1758388240, 1023494292, 719963017, 1883763832, 597498209, 367814403, 1839429063, 223575614, 79701214, 1699606118, 759455864, 2017599457);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 == b1, r1);
+
+            uint a2 = (1395605233);
+            uint4x4 b2 = uint4x4(1191785903, 1156248212, 338891967, 61410415, 1576985758, 1066598856, 1070606918, 1295956934, 1391539053, 1206456305, 466211205, 1362213007, 554347592, 361925309, 1122476040, 1118155036);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 == b2, r2);
+
+            uint a3 = (2074160001);
+            uint4x4 b3 = uint4x4(211145132, 1330427155, 231737739, 590220146, 622950505, 2048231874, 682985774, 865101790, 1523019859, 261373300, 132547968, 1971091157, 982104573, 1456888767, 1700538931, 1590557254);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 == b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_not_equal_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1660932106, 982847023, 97046264, 1739517447, 1253499180, 1830584069, 1841470429, 1397841646, 1770890135, 1906548631, 169082967, 2099271786, 1909317609, 46519139, 1433204003, 931492669);
+            uint4x4 b0 = uint4x4(107139049, 75478496, 2055495054, 358586687, 942338347, 111564990, 113811950, 948912488, 1080084121, 1400504872, 1032134499, 1061123400, 221862069, 858950046, 989094643, 2023070999);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x4 a1 = uint4x4(670504132, 1551558665, 1204055048, 1623586740, 226381077, 1145987803, 644253929, 475189890, 922313145, 2006448607, 1574579050, 1839580033, 155350910, 313644534, 2008975915, 1072866331);
+            uint4x4 b1 = uint4x4(1269317127, 531883744, 687761409, 278427731, 296354221, 536981557, 1134676193, 1749879634, 1944210269, 92849031, 164029425, 628797607, 2069207270, 2022667842, 880567401, 264404537);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x4 a2 = uint4x4(10845678, 1588544505, 709736932, 1892341087, 1603981028, 1174123795, 2033630343, 416869471, 1894155826, 2084120548, 1130129683, 448491949, 1577220741, 376532834, 374116875, 416935463);
+            uint4x4 b2 = uint4x4(1954996717, 572153302, 865957902, 1083128726, 1628120900, 2020212393, 1562290229, 774641416, 444123152, 1636477381, 838643638, 506474707, 922761058, 1282331425, 1748402545, 1493297323);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x4 a3 = uint4x4(1370971537, 526135879, 1693615335, 1040142702, 51869182, 636351650, 1137389277, 742650911, 1652337799, 128512016, 943930500, 1281758501, 1506504768, 1142416208, 489425068, 709011851);
+            uint4x4 b3 = uint4x4(881583266, 836740859, 2050520235, 56355243, 923319881, 2093941797, 1966851287, 740544328, 1686486765, 1564852763, 1583872597, 1319685687, 1082069798, 1934459521, 610009662, 2003062130);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_not_equal_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(747758183, 1033001286, 1439973882, 2138928797, 1197845089, 1432672459, 950170763, 238704450, 2105962247, 727205263, 1640688041, 276313906, 2126300423, 791998981, 2035077187, 1171827730);
+            uint b0 = (248693828);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint4x4 a1 = uint4x4(1412347883, 768370497, 1072798259, 1808712713, 1497830076, 1582645163, 1876273820, 90244766, 30493685, 904014575, 384643370, 11554610, 2016093187, 1515760622, 1596313927, 363921847);
+            uint b1 = (1622176923);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint4x4 a2 = uint4x4(1555396158, 1739138988, 1916670251, 1516209113, 765258490, 668154629, 1509386069, 1670155205, 6112585, 1942607934, 964072392, 779222124, 409389668, 321500037, 1728722181, 1641292942);
+            uint b2 = (913218907);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint4x4 a3 = uint4x4(780105497, 1311007738, 2079744789, 1086529117, 898347399, 1597839770, 1711183709, 2048684031, 1167351404, 528657884, 565527393, 227149840, 89869060, 1358928288, 44374114, 2059875706);
+            uint b3 = (1302143939);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_not_equal_scalar_wide()
+        {
+            uint a0 = (2076921066);
+            uint4x4 b0 = uint4x4(2037494727, 1989050616, 48833929, 1897435904, 514354517, 1783749164, 364694471, 754315072, 124108032, 1512967900, 1178825850, 1854793298, 50286949, 2100802631, 1640811853, 82110247);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 != b0, r0);
+
+            uint a1 = (472172806);
+            uint4x4 b1 = uint4x4(266984506, 2003668365, 1826089250, 1041416160, 356140110, 2057237962, 799920703, 1916347720, 510966350, 572038024, 1936481966, 1366859342, 1775285431, 604757336, 1047551607, 1311703338);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 != b1, r1);
+
+            uint a2 = (676012224);
+            uint4x4 b2 = uint4x4(627370253, 1715733805, 699755913, 1875151666, 358894860, 1036873378, 214171973, 340364269, 1652250278, 592713982, 806342921, 1264065574, 188560943, 1068608955, 485382245, 57935167);
+            bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 != b2, r2);
+
+            uint a3 = (1002934795);
+            uint4x4 b3 = uint4x4(1859322106, 1990390938, 1674000894, 1035504906, 1681354617, 2079296301, 1396396873, 2128571831, 3388167, 1211711140, 575696152, 1534939377, 496306248, 908210564, 131274243, 543089960);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 != b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1182186063, 415538999, 1667335818, 1566618442, 1166180837, 639095188, 1080836365, 771119973, 928263233, 789225474, 665243110, 1003542034, 1032480172, 1961336172, 923379558, 21210619);
+            uint4x4 b0 = uint4x4(524633529, 1032195686, 760723389, 1505751409, 431962172, 1287906509, 1560084663, 1450178202, 2066166337, 1107069023, 1640077524, 2103263105, 684229139, 1234033624, 1278743281, 1953079347);
+            bool4x4 r0 = bool4x4(false, true, false, false, false, true, true, true, true, true, true, true, false, false, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x4 a1 = uint4x4(1089772116, 1707633052, 778986024, 158153146, 336715101, 1839141169, 1706859710, 1928438162, 1638101724, 2044698552, 1543260981, 471462349, 1668575142, 2147199161, 946870864, 582371851);
+            uint4x4 b1 = uint4x4(1228832942, 2082539723, 1088437561, 1058382082, 207459172, 750531081, 2015788562, 2126542133, 271967348, 1601249324, 1373999400, 1689592186, 459759541, 983106679, 332584818, 2034921203);
+            bool4x4 r1 = bool4x4(true, true, true, true, false, false, true, true, false, false, false, true, false, false, false, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x4 a2 = uint4x4(410751553, 198134393, 1999935258, 671192178, 1908013191, 770353922, 1948420002, 396403395, 903274624, 1743415547, 1381528376, 409818366, 757370593, 413964581, 1088722047, 111511218);
+            uint4x4 b2 = uint4x4(833499488, 1999487070, 836063897, 1987309319, 1878327039, 457783938, 253010953, 1164175257, 1982277686, 651412210, 567444942, 1863256363, 18040866, 319226483, 1322530114, 4130283);
+            bool4x4 r2 = bool4x4(true, true, false, true, false, false, false, true, true, false, false, true, false, false, true, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x4 a3 = uint4x4(1772570968, 339779528, 1817654169, 126606875, 1748258817, 1840719780, 603645478, 1888655831, 63356146, 79832055, 736652918, 653392827, 423681122, 1242116477, 422099316, 898587272);
+            uint4x4 b3 = uint4x4(1951703613, 873360222, 2076434739, 802037827, 57389233, 1812417589, 13678411, 1415564189, 983023904, 1112076825, 2078443288, 1990790258, 482361677, 1981894392, 351965695, 585483077);
+            bool4x4 r3 = bool4x4(true, true, true, true, false, false, false, false, true, true, true, true, true, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(608447185, 818840405, 869219329, 2080125385, 1214500548, 1361741203, 1667165786, 1615392341, 840091491, 469591900, 1247103789, 315321650, 930950514, 1100560246, 933855388, 908563901);
+            uint b0 = (1491216667);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, false, false, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint4x4 a1 = uint4x4(1127696709, 380753337, 971148054, 1827886929, 1056649851, 1579735991, 689044913, 1960894027, 371987110, 867559111, 1703747625, 1698536333, 41716206, 243673862, 1274625476, 611065092);
+            uint b1 = (1286331950);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, true, true, true);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint4x4 a2 = uint4x4(118750042, 452204442, 1645191336, 1829152606, 1891059504, 1217893177, 233590785, 894500093, 92899312, 965973603, 1496873003, 973411415, 694702440, 215973795, 1555455579, 1443255493);
+            uint b2 = (1829327996);
+            bool4x4 r2 = bool4x4(true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint4x4 a3 = uint4x4(212954934, 1031281872, 1389987778, 928043903, 434566816, 1386588061, 180174416, 119231358, 842513438, 494182092, 2110901808, 2064339655, 798375285, 225918038, 2119961960, 1851740205);
+            uint b3 = (519181838);
+            bool4x4 r3 = bool4x4(true, false, false, false, true, false, true, true, false, true, false, false, false, true, false, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_scalar_wide()
+        {
+            uint a0 = (548436837);
+            uint4x4 b0 = uint4x4(282703327, 14370648, 1862117300, 1304793311, 826073259, 988910157, 445132446, 1139670255, 111349251, 1102440676, 112183144, 1594415311, 1890019295, 2098715503, 608933527, 183989010);
+            bool4x4 r0 = bool4x4(false, false, true, true, true, true, false, true, false, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 < b0, r0);
+
+            uint a1 = (1596056507);
+            uint4x4 b1 = uint4x4(1027318999, 146281093, 358911716, 874278078, 1106057699, 1256807459, 2111973919, 1736480659, 810406400, 1329939911, 1276652605, 593690439, 771851138, 590897155, 386688344, 1290583204);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, true, true, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 < b1, r1);
+
+            uint a2 = (1984930954);
+            uint4x4 b2 = uint4x4(743544838, 1473400608, 1300775973, 1351720916, 168788814, 670661854, 168118205, 894264935, 1763013903, 1647476162, 699045651, 1813273687, 900504872, 1574770031, 1684716245, 1458270033);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a2 < b2, r2);
+
+            uint a3 = (685700324);
+            uint4x4 b3 = uint4x4(697607066, 378454814, 1198070277, 1821642406, 1324129275, 905046836, 1897627028, 1715796299, 15666859, 1806453893, 1315963488, 545979816, 1486981760, 511543521, 1872978447, 303832107);
+            bool4x4 r3 = bool4x4(true, false, true, true, true, true, true, true, false, true, true, false, true, false, true, false);
+            TestUtils.AreEqual(a3 < b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(592884447, 2133928932, 918957182, 1284069471, 194584707, 739120780, 241654068, 1340158550, 2099542537, 1182623667, 1399607274, 789301637, 180400925, 594688333, 1877031463, 1360073500);
+            uint4x4 b0 = uint4x4(138737040, 192863971, 1700841444, 1044631301, 1391589821, 730837695, 253553987, 2078872742, 910845808, 976047676, 202633078, 1223618940, 641600530, 1830470354, 1570701388, 1104256103);
+            bool4x4 r0 = bool4x4(true, true, false, true, false, true, false, false, true, true, true, false, false, false, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x4 a1 = uint4x4(1091782422, 546676424, 348221770, 716039145, 458742739, 1365508046, 1523167942, 1574478622, 1295065160, 715285504, 1130323487, 677530432, 1496919050, 12463046, 1106153111, 1315083485);
+            uint4x4 b1 = uint4x4(1838646932, 740166101, 1549021845, 1457092873, 1790630950, 907793213, 555122804, 1418910265, 335209251, 1094341422, 1465325455, 390251369, 910309992, 277356652, 1601082764, 771366966);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, true, true, true, true, false, false, true, true, false, false, true);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x4 a2 = uint4x4(31516321, 1786538920, 1854361210, 1730650972, 194806663, 517304937, 984608679, 1847934645, 1214605555, 535405194, 855415884, 2121416263, 1161116500, 1390730698, 1536558799, 350939762);
+            uint4x4 b2 = uint4x4(1782348324, 550490783, 599992449, 550520692, 1873014441, 1756459971, 2028992071, 1772761768, 1323261715, 1541822212, 265732078, 1773940614, 156425055, 1585395425, 438682493, 1005143622);
+            bool4x4 r2 = bool4x4(false, true, true, true, false, false, false, true, false, false, true, true, true, false, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x4 a3 = uint4x4(475547465, 876276892, 916067531, 1712032702, 752041926, 899534759, 948020518, 1553126337, 1209858994, 1210234744, 1065677570, 2063434729, 1808415708, 1536857930, 1356745398, 1161445540);
+            uint4x4 b3 = uint4x4(594141080, 1888303265, 1023987839, 695072711, 164764812, 1404792693, 1068554108, 1615410626, 387184925, 1930375043, 1920744920, 1913267890, 12598306, 1697936155, 145255547, 1903607817);
+            bool4x4 r3 = bool4x4(false, false, false, true, true, false, false, false, true, false, false, true, true, false, true, false);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(1097138316, 211763648, 1883002501, 56406996, 43662641, 1923456111, 1437755186, 1219010035, 2125058448, 304028799, 893125636, 48044515, 711945018, 1035679270, 577943770, 572743717);
+            uint b0 = (438688675);
+            bool4x4 r0 = bool4x4(true, false, true, false, false, true, true, true, true, false, true, false, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint4x4 a1 = uint4x4(1016617211, 1577403353, 64009107, 1462961460, 1143565920, 3715845, 689362811, 263973424, 1045140419, 1058332184, 524569092, 1183316983, 1107974092, 212839726, 523727054, 112709358);
+            uint b1 = (2063134811);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint4x4 a2 = uint4x4(614746280, 1683117650, 1451781409, 61102732, 1284938191, 1452639553, 2125085618, 467075658, 1019531089, 2028286621, 940955706, 1037153304, 1184928188, 1260010015, 1456174269, 174216269);
+            uint b2 = (1000986708);
+            bool4x4 r2 = bool4x4(false, true, true, false, true, true, true, false, true, true, false, true, true, true, true, false);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint4x4 a3 = uint4x4(1930086291, 2112194236, 1797322269, 1781660503, 1442606402, 208047803, 1193639690, 1939917219, 1146005869, 865123927, 913186094, 35693052, 1017084356, 91189073, 369398582, 2082818804);
+            uint b3 = (108635332);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_scalar_wide()
+        {
+            uint a0 = (2024896938);
+            uint4x4 b0 = uint4x4(599356784, 185671342, 1932327391, 2025591013, 1257191721, 1312388500, 1443698859, 779217735, 691047512, 741776730, 732565983, 668302204, 1556466996, 858599525, 1896917159, 701542098);
+            bool4x4 r0 = bool4x4(true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 > b0, r0);
+
+            uint a1 = (1052151621);
+            uint4x4 b1 = uint4x4(1023307544, 1435392907, 1858177345, 299897686, 632930355, 1387203601, 483722222, 863042711, 1713088900, 315569296, 292652611, 1002628348, 927789921, 108145064, 425005337, 2093233588);
+            bool4x4 r1 = bool4x4(true, false, false, true, true, false, true, true, false, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 > b1, r1);
+
+            uint a2 = (2063431853);
+            uint4x4 b2 = uint4x4(2079035844, 849337819, 1769234051, 358948261, 267985383, 126402553, 2055164423, 577620406, 1167389614, 474380256, 1163355187, 1782967398, 1648397169, 845981950, 630459977, 1033887217);
+            bool4x4 r2 = bool4x4(false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a2 > b2, r2);
+
+            uint a3 = (1480829811);
+            uint4x4 b3 = uint4x4(1903710461, 402220631, 266619022, 1724999252, 2113910076, 945951388, 1448605169, 1162548302, 1691586468, 996819204, 1151046248, 1924073034, 1910741238, 633631666, 307560646, 722552263);
+            bool4x4 r3 = bool4x4(false, true, true, false, false, true, true, true, false, true, true, false, false, true, true, true);
+            TestUtils.AreEqual(a3 > b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_equal_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1577248162, 2043073061, 1688380407, 176431985, 223299035, 1502802140, 1691709825, 386789394, 117182003, 1665770435, 1958490731, 420032601, 1251092689, 2011681765, 749743684, 183784440);
+            uint4x4 b0 = uint4x4(903445031, 2108974565, 210822256, 1281704747, 453681718, 66138830, 1229799377, 1620922595, 1715833766, 1366430432, 13102000, 46919981, 486470891, 1709514236, 2145785285, 854254454);
+            bool4x4 r0 = bool4x4(false, true, false, true, true, false, false, true, true, false, false, false, false, false, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x4 a1 = uint4x4(1150674774, 1633828822, 1719442172, 336047314, 743733218, 1393995865, 1854442658, 1498138884, 912169992, 1992682021, 1619593455, 1883313982, 483412430, 857881876, 346624138, 531961063);
+            uint4x4 b1 = uint4x4(1273278658, 810263315, 1862773824, 201799013, 974166844, 1320622967, 2058099616, 522102017, 620752145, 1213693681, 1281818305, 1564146162, 1996153080, 1201909516, 614401396, 224997397);
+            bool4x4 r1 = bool4x4(true, false, true, false, true, false, true, false, false, false, false, false, true, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x4 a2 = uint4x4(269897278, 1062947703, 1743454202, 2048964070, 1379786452, 622697214, 766589782, 339960970, 1135815654, 797344244, 153103264, 1382144646, 1537448323, 326850885, 1004891948, 2002658522);
+            uint4x4 b2 = uint4x4(648547686, 418431167, 1724009726, 401891826, 1463971422, 984323887, 1246893281, 1340476720, 1489579748, 128991539, 1117574406, 2016340116, 69682660, 1870772739, 1281621445, 129331822);
+            bool4x4 r2 = bool4x4(true, false, false, false, true, true, true, true, true, false, true, true, false, true, true, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x4 a3 = uint4x4(442205781, 1050725689, 995151913, 926131462, 719271722, 1981390876, 659121091, 797556380, 1656192110, 66093862, 1964540799, 71894133, 1413886687, 1028466491, 1397158841, 1544483525);
+            uint4x4 b3 = uint4x4(1168998468, 1205894972, 1079707717, 1335643913, 1590790195, 155622033, 898990095, 1384002796, 1664888803, 1004528037, 402969524, 1299806519, 1194091234, 1673771542, 178191331, 98165007);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, false, true, true, true, true, false, true, false, true, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_equal_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(1722165358, 1219858357, 860410743, 411099660, 348104022, 1963256951, 212084836, 58924407, 1459242706, 1745758438, 532949158, 262559763, 690091301, 1806172431, 2091514001, 1857173043);
+            uint b0 = (1688048545);
+            bool4x4 r0 = bool4x4(false, true, true, true, true, false, true, true, true, false, true, true, true, false, false, false);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint4x4 a1 = uint4x4(1617221948, 804204255, 981729559, 2032949254, 910922522, 2079225209, 26179915, 238796519, 1917813750, 1258115260, 20607406, 1337879822, 959460446, 1599429457, 1279143037, 1551937606);
+            uint b1 = (2017733017);
+            bool4x4 r1 = bool4x4(true, true, true, false, true, false, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint4x4 a2 = uint4x4(626254356, 1021674613, 127839058, 1974631244, 426908235, 1818566980, 487782623, 1454736163, 465255784, 686095683, 2012624010, 1427922646, 1129062501, 1896996725, 1609784025, 1413823266);
+            uint b2 = (1162369122);
+            bool4x4 r2 = bool4x4(true, true, true, false, true, false, true, false, true, true, false, false, true, false, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint4x4 a3 = uint4x4(1483727269, 1823599046, 1379007149, 1836699751, 777126023, 1288116795, 834230828, 172303141, 577773919, 705141691, 191477430, 868528232, 499782260, 146328981, 1401289768, 858105804);
+            uint b3 = (2045244870);
+            bool4x4 r3 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_less_equal_scalar_wide()
+        {
+            uint a0 = (1777585);
+            uint4x4 b0 = uint4x4(1181030049, 1787703989, 1729760948, 1816537388, 1359786460, 874999193, 1678863148, 1711365839, 762067160, 11953554, 1131583906, 1175393186, 1293698493, 48893340, 66196247, 1958607116);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+            TestUtils.AreEqual(a0 <= b0, r0);
+
+            uint a1 = (1576473309);
+            uint4x4 b1 = uint4x4(861890786, 478252419, 957887737, 117849810, 1348693584, 105489302, 259034238, 530713566, 601413850, 830430286, 145552297, 1697295044, 1150680564, 2091065664, 1796096704, 1572008712);
+            bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, true, false, true, true, false);
+            TestUtils.AreEqual(a1 <= b1, r1);
+
+            uint a2 = (1556906486);
+            uint4x4 b2 = uint4x4(205552788, 620963188, 1156705971, 1121867260, 733876180, 1570208446, 541165966, 644414754, 734807383, 938714737, 591783460, 56988751, 790541516, 1811299247, 1308256680, 549490410);
+            bool4x4 r2 = bool4x4(false, false, false, false, false, true, false, false, false, false, false, false, false, true, false, false);
+            TestUtils.AreEqual(a2 <= b2, r2);
+
+            uint a3 = (1987696011);
+            uint4x4 b3 = uint4x4(1079808067, 363499438, 1873483674, 2031411422, 1979820112, 1682214687, 1470726710, 1285823822, 758372610, 44568907, 1533310851, 14070795, 1758870243, 68371537, 1482970849, 1750868121);
+            bool4x4 r3 = bool4x4(false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 <= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_equal_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(263000030, 744235661, 1893760267, 237248, 1062370984, 1676977687, 816766880, 1089431546, 1394493730, 1176473380, 1193988637, 1703862455, 1806186947, 1253571980, 589397635, 1951842887);
+            uint4x4 b0 = uint4x4(1395535146, 1178373944, 1237373760, 1364855321, 600811864, 362060472, 290870624, 1839067862, 396958580, 1336888643, 1019684398, 1697684196, 1227300220, 2044269675, 1898323839, 874509380);
+            bool4x4 r0 = bool4x4(false, false, true, false, true, true, true, false, true, false, true, true, true, false, false, true);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x4 a1 = uint4x4(798931197, 808426484, 744869638, 1959531616, 207430702, 1533946595, 1148381840, 2011549474, 605043041, 1707339660, 2038122892, 345761584, 1839156338, 1519670644, 2131285427, 775457686);
+            uint4x4 b1 = uint4x4(1873505472, 1268843918, 1606949562, 1263896445, 1805518202, 1412091359, 1240330374, 1955056253, 2025187918, 750755999, 869709740, 1390799279, 1194035112, 666460047, 103451220, 1311530792);
+            bool4x4 r1 = bool4x4(false, false, false, true, false, true, false, true, false, true, true, false, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x4 a2 = uint4x4(796452624, 1710612922, 1629927787, 1094198224, 584910611, 1129457941, 1633221450, 549302356, 1363234393, 1439226634, 190984179, 983870135, 1527743888, 1577171227, 87278918, 1280094665);
+            uint4x4 b2 = uint4x4(802468307, 1090745055, 1968071275, 1935027815, 2060060582, 1535954082, 291771096, 565856573, 1445999374, 711693364, 1201086888, 2076705104, 1565110852, 1698318173, 1293071569, 103979482);
+            bool4x4 r2 = bool4x4(false, true, false, false, false, false, true, false, false, true, false, false, false, false, false, true);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x4 a3 = uint4x4(1030060516, 615638735, 1677201099, 325128466, 930989694, 165845388, 1887735446, 1905061476, 644732756, 1450709301, 811708233, 1120546613, 1966081819, 1710484814, 390900048, 1847748897);
+            uint4x4 b3 = uint4x4(222415803, 345913533, 920804419, 784455413, 1919795492, 2125545957, 957291149, 1547385242, 953814071, 685286053, 63764322, 1742849383, 1781391465, 64816935, 1543363698, 1439322689);
+            bool4x4 r3 = bool4x4(true, true, true, false, false, false, true, true, false, true, true, false, true, true, false, true);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_equal_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(2112791350, 1043657935, 101764761, 1529909067, 556026890, 281734132, 1186600258, 815093894, 609211196, 1604309397, 829548642, 244604867, 1419295004, 471843809, 1819986195, 1460027917);
+            uint b0 = (1470533736);
+            bool4x4 r0 = bool4x4(true, false, false, true, false, false, false, false, false, true, false, false, false, false, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint4x4 a1 = uint4x4(1646290021, 1596738181, 1905036391, 1771391775, 1584946560, 370941146, 440219668, 1607345862, 1449142607, 1223010129, 379014762, 1719435169, 258833609, 1389585003, 612593660, 42612027);
+            uint b1 = (196833647);
+            bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint4x4 a2 = uint4x4(1138747386, 917503963, 353608194, 1526792895, 192092521, 909358617, 367754234, 1738737389, 523396822, 594728703, 1332667659, 1627604854, 1542713928, 1997611484, 191413337, 1230701700);
+            uint b2 = (1491562090);
+            bool4x4 r2 = bool4x4(false, false, false, true, false, false, false, true, false, false, false, true, true, true, false, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint4x4 a3 = uint4x4(702382564, 1013770865, 1420374964, 341399575, 2033070823, 672716789, 1809028740, 2070046852, 1254367930, 1206207650, 807585496, 1243142372, 350377587, 214724394, 216954982, 201992840);
+            uint b3 = (2086058548);
+            bool4x4 r3 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_greater_equal_scalar_wide()
+        {
+            uint a0 = (1525542481);
+            uint4x4 b0 = uint4x4(1503244746, 861711266, 817773856, 925984572, 571221723, 683686810, 118252990, 1653952090, 1240253990, 1947039008, 1869136019, 152012637, 1214546726, 917376832, 303549425, 2111728811);
+            bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, false, true, false, false, true, true, true, true, false);
+            TestUtils.AreEqual(a0 >= b0, r0);
+
+            uint a1 = (945321577);
+            uint4x4 b1 = uint4x4(173706579, 625318949, 519443238, 1583588379, 1026799433, 1713083717, 394922760, 1216218189, 1336522452, 233894308, 479913036, 984991199, 172993285, 2121050903, 465645173, 788510727);
+            bool4x4 r1 = bool4x4(true, true, true, false, false, false, true, false, false, true, true, false, true, false, true, true);
+            TestUtils.AreEqual(a1 >= b1, r1);
+
+            uint a2 = (337378780);
+            uint4x4 b2 = uint4x4(273010835, 1898553615, 1111540136, 717385513, 474197678, 1417152771, 1476091619, 1312849725, 243299324, 1470872301, 1443256118, 1203165035, 2138148138, 1543595760, 186659728, 807288168);
+            bool4x4 r2 = bool4x4(true, false, false, false, false, false, false, false, true, false, false, false, false, false, true, false);
+            TestUtils.AreEqual(a2 >= b2, r2);
+
+            uint a3 = (1274079907);
+            uint4x4 b3 = uint4x4(1834102381, 22983902, 1733648920, 2089437749, 476445313, 1296111196, 422851096, 1857250030, 1382182918, 449792502, 1785823601, 668960891, 1067260705, 1973471752, 1403490846, 1510985557);
+            bool4x4 r3 = bool4x4(false, true, false, false, true, false, true, false, false, true, false, true, true, false, false, false);
+            TestUtils.AreEqual(a3 >= b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_add_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(2049228671, 1658660009, 491719392, 937013355, 81108663, 1063894558, 86954702, 843159721, 698977704, 192867135, 1683407172, 137301303, 2103582820, 526139155, 447937230, 2127411006);
+            uint4x4 b0 = uint4x4(2088751567, 645762023, 306868786, 4360271, 506047997, 2094559874, 1634712736, 1601474440, 1586485231, 908746788, 1812370320, 1247342357, 2043773873, 223363428, 175115707, 985928617);
+            uint4x4 r0 = uint4x4(4137980238, 2304422032, 798588178, 941373626, 587156660, 3158454432, 1721667438, 2444634161, 2285462935, 1101613923, 3495777492, 1384643660, 4147356693, 749502583, 623052937, 3113339623);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x4 a1 = uint4x4(1670579390, 1914969141, 997691756, 857841794, 2129024875, 267535529, 978891383, 657092366, 941872903, 906908654, 1940071697, 862186205, 1951450264, 689662850, 1928213278, 1703906688);
+            uint4x4 b1 = uint4x4(507662836, 1231457019, 776127866, 607782424, 1160366210, 1384832242, 702057048, 703554905, 2106992817, 1994483489, 539473, 236858351, 411317652, 595429166, 713649927, 2053476603);
+            uint4x4 r1 = uint4x4(2178242226, 3146426160, 1773819622, 1465624218, 3289391085, 1652367771, 1680948431, 1360647271, 3048865720, 2901392143, 1940611170, 1099044556, 2362767916, 1285092016, 2641863205, 3757383291);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x4 a2 = uint4x4(526120638, 423980484, 1867227242, 603782684, 728643437, 927205560, 1544834791, 268450974, 1386681507, 1428974172, 1415690700, 1193340567, 1792960278, 1427490402, 86465016, 827052793);
+            uint4x4 b2 = uint4x4(77965941, 1726775513, 1759186349, 2070333485, 1732568358, 523040962, 899952708, 1401525772, 1970067897, 488428060, 132927517, 1670039917, 1678110790, 586374104, 262412628, 1415374948);
+            uint4x4 r2 = uint4x4(604086579, 2150755997, 3626413591, 2674116169, 2461211795, 1450246522, 2444787499, 1669976746, 3356749404, 1917402232, 1548618217, 2863380484, 3471071068, 2013864506, 348877644, 2242427741);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x4 a3 = uint4x4(1603943169, 858711604, 278076564, 983811310, 1503210133, 1265840052, 1220817560, 839507207, 142866678, 1356231306, 1432159402, 637785903, 1032109021, 2081298882, 331695947, 1983868469);
+            uint4x4 b3 = uint4x4(361542573, 900925442, 1077800500, 1330170201, 984058816, 207503339, 339145243, 1051497556, 1435620725, 2105629028, 1215478628, 393193121, 901424214, 189116452, 17408580, 466230809);
+            uint4x4 r3 = uint4x4(1965485742, 1759637046, 1355877064, 2313981511, 2487268949, 1473343391, 1559962803, 1891004763, 1578487403, 3461860334, 2647638030, 1030979024, 1933533235, 2270415334, 349104527, 2450099278);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_add_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(2038218457, 134923711, 875689667, 1338884463, 997710928, 340490871, 1067888129, 70433301, 2003021861, 1635971971, 1160398286, 85446202, 1068152966, 1239387100, 1497676888, 1727477485);
+            uint b0 = (2124409227);
+            uint4x4 r0 = uint4x4(4162627684, 2259332938, 3000098894, 3463293690, 3122120155, 2464900098, 3192297356, 2194842528, 4127431088, 3760381198, 3284807513, 2209855429, 3192562193, 3363796327, 3622086115, 3851886712);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint4x4 a1 = uint4x4(1095438654, 1818718931, 658923552, 1610518921, 1585755398, 692843300, 1068593469, 1704776233, 577782260, 736972565, 711894571, 564257439, 2051736283, 1572837697, 1628006545, 1855700263);
+            uint b1 = (756559204);
+            uint4x4 r1 = uint4x4(1851997858, 2575278135, 1415482756, 2367078125, 2342314602, 1449402504, 1825152673, 2461335437, 1334341464, 1493531769, 1468453775, 1320816643, 2808295487, 2329396901, 2384565749, 2612259467);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint4x4 a2 = uint4x4(656748782, 1917133199, 828322973, 2116810190, 2092767444, 973587865, 1236931273, 504264449, 794292574, 1518058681, 1604636324, 354873417, 685247897, 227781140, 321182517, 1210575914);
+            uint b2 = (272774516);
+            uint4x4 r2 = uint4x4(929523298, 2189907715, 1101097489, 2389584706, 2365541960, 1246362381, 1509705789, 777038965, 1067067090, 1790833197, 1877410840, 627647933, 958022413, 500555656, 593957033, 1483350430);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint4x4 a3 = uint4x4(1340503111, 1979965576, 1988286575, 427699536, 538653829, 1589564058, 1954579845, 1781591877, 419928668, 1751001953, 355993558, 1653659509, 2098769225, 63134274, 1679875388, 377229586);
+            uint b3 = (838567468);
+            uint4x4 r3 = uint4x4(2179070579, 2818533044, 2826854043, 1266267004, 1377221297, 2428131526, 2793147313, 2620159345, 1258496136, 2589569421, 1194561026, 2492226977, 2937336693, 901701742, 2518442856, 1215797054);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_add_scalar_wide()
+        {
+            uint a0 = (391092078);
+            uint4x4 b0 = uint4x4(519908870, 851424292, 328314822, 135622204, 740923360, 655394201, 1451896269, 1781697072, 996031825, 1557774949, 779774940, 1111541302, 783046445, 1130163944, 288279584, 1397683861);
+            uint4x4 r0 = uint4x4(911000948, 1242516370, 719406900, 526714282, 1132015438, 1046486279, 1842988347, 2172789150, 1387123903, 1948867027, 1170867018, 1502633380, 1174138523, 1521256022, 679371662, 1788775939);
+            TestUtils.AreEqual(a0 + b0, r0);
+
+            uint a1 = (1636583489);
+            uint4x4 b1 = uint4x4(673263339, 1469300874, 14855965, 1116636999, 1488863300, 1600990886, 190651301, 1307459768, 920085839, 2082229835, 1992405574, 1213924458, 505841452, 981421162, 1488337699, 1113826640);
+            uint4x4 r1 = uint4x4(2309846828, 3105884363, 1651439454, 2753220488, 3125446789, 3237574375, 1827234790, 2944043257, 2556669328, 3718813324, 3628989063, 2850507947, 2142424941, 2618004651, 3124921188, 2750410129);
+            TestUtils.AreEqual(a1 + b1, r1);
+
+            uint a2 = (1806146508);
+            uint4x4 b2 = uint4x4(1841791222, 206610851, 526971953, 1236359886, 1459523189, 965740631, 82842799, 1298403201, 1805809772, 1978864191, 415003386, 1906304148, 722870197, 744248796, 1677223559, 303376031);
+            uint4x4 r2 = uint4x4(3647937730, 2012757359, 2333118461, 3042506394, 3265669697, 2771887139, 1888989307, 3104549709, 3611956280, 3785010699, 2221149894, 3712450656, 2529016705, 2550395304, 3483370067, 2109522539);
+            TestUtils.AreEqual(a2 + b2, r2);
+
+            uint a3 = (1275565021);
+            uint4x4 b3 = uint4x4(1518386617, 233426699, 1128986758, 1421938726, 1178529217, 1397917053, 137663521, 975646083, 1968321168, 720648013, 1606974342, 567772614, 490190373, 576353787, 1438920888, 2145198309);
+            uint4x4 r3 = uint4x4(2793951638, 1508991720, 2404551779, 2697503747, 2454094238, 2673482074, 1413228542, 2251211104, 3243886189, 1996213034, 2882539363, 1843337635, 1765755394, 1851918808, 2714485909, 3420763330);
+            TestUtils.AreEqual(a3 + b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_sub_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1353441118, 797269833, 659988112, 56022121, 365847472, 2062899435, 1380988474, 799885138, 1306058185, 579775276, 1239163824, 344591081, 86359575, 1049709943, 721529513, 1767221271);
+            uint4x4 b0 = uint4x4(1332656812, 1827794007, 972557431, 2078233689, 1508184327, 1372307701, 810327977, 936799885, 71562303, 1418723328, 1971342989, 1226053395, 136565478, 1979903295, 600719425, 837912956);
+            uint4x4 r0 = uint4x4(20784306, 3264443122, 3982397977, 2272755728, 3152630441, 690591734, 570660497, 4158052549, 1234495882, 3456019244, 3562788131, 3413504982, 4244761393, 3364773944, 120810088, 929308315);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x4 a1 = uint4x4(7652784, 545192611, 176298787, 1477774126, 1426963688, 2032787858, 2059525977, 445200454, 425848588, 2026967474, 1128492011, 61421784, 988065731, 1741434432, 2070331135, 1356704176);
+            uint4x4 b1 = uint4x4(632054793, 711091688, 904695656, 1640069560, 750244414, 1385118097, 1102391291, 1221949855, 609588723, 1054324682, 1678086165, 1529581776, 1718700085, 523422634, 223602473, 1912611694);
+            uint4x4 r1 = uint4x4(3670565287, 4129068219, 3566570427, 4132671862, 676719274, 647669761, 957134686, 3518217895, 4111227161, 972642792, 3745373142, 2826807304, 3564332942, 1218011798, 1846728662, 3739059778);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x4 a2 = uint4x4(1888446703, 1364654917, 265135366, 760501098, 741271824, 2139243287, 2086038778, 1314011065, 1838848671, 1554054707, 721235598, 1856904592, 570633009, 1870509604, 1310744871, 1717222072);
+            uint4x4 b2 = uint4x4(1224986479, 748933681, 88793450, 401362529, 1087189363, 488919410, 1106956631, 1131451931, 1975243735, 111940790, 712896589, 477050266, 1163094482, 605082349, 954351492, 1203361215);
+            uint4x4 r2 = uint4x4(663460224, 615721236, 176341916, 359138569, 3949049757, 1650323877, 979082147, 182559134, 4158572232, 1442113917, 8339009, 1379854326, 3702505823, 1265427255, 356393379, 513860857);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x4 a3 = uint4x4(1541023885, 1644155041, 1885220021, 956814489, 1996571272, 313052858, 1686326525, 1591026645, 404689020, 832057610, 817031413, 1191376096, 1515565534, 178300672, 365767493, 1238101305);
+            uint4x4 b3 = uint4x4(120176164, 834539498, 1843750420, 337055138, 1625604945, 41302648, 1719986021, 2028592747, 609982501, 95087400, 1244763386, 1175550114, 887604651, 1249524531, 155418749, 1934403979);
+            uint4x4 r3 = uint4x4(1420847721, 809615543, 41469601, 619759351, 370966327, 271750210, 4261307800, 3857401194, 4089673815, 736970210, 3867235323, 15825982, 627960883, 3223743437, 210348744, 3598664622);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_sub_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(1176369558, 1934521195, 309452150, 1417634074, 108910717, 1306356714, 1502312334, 1451794815, 281174200, 87530840, 1913724431, 2041593336, 557239990, 1119051448, 1590376732, 819090189);
+            uint b0 = (462232403);
+            uint4x4 r0 = uint4x4(714137155, 1472288792, 4142187043, 955401671, 3941645610, 844124311, 1040079931, 989562412, 4113909093, 3920265733, 1451492028, 1579360933, 95007587, 656819045, 1128144329, 356857786);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint4x4 a1 = uint4x4(816382635, 1829033117, 1792801932, 1113440549, 1418937976, 1277257189, 2092779398, 642236742, 1605250794, 819644478, 1468003019, 128303186, 553494257, 1017126971, 1999744782, 2017272758);
+            uint b1 = (815920639);
+            uint4x4 r1 = uint4x4(461996, 1013112478, 976881293, 297519910, 603017337, 461336550, 1276858759, 4121283399, 789330155, 3723839, 652082380, 3607349843, 4032540914, 201206332, 1183824143, 1201352119);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint4x4 a2 = uint4x4(1817991764, 676974855, 1638032613, 949761204, 1835969317, 919015590, 976947310, 1304246606, 1456780208, 1554022712, 769804365, 2057831687, 758136579, 670433255, 603231411, 1673268965);
+            uint b2 = (1280985500);
+            uint4x4 r2 = uint4x4(537006264, 3690956651, 357047113, 3963743000, 554983817, 3932997386, 3990929106, 23261106, 175794708, 273037212, 3783786161, 776846187, 3772118375, 3684415051, 3617213207, 392283465);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint4x4 a3 = uint4x4(941598524, 1394256067, 1267352835, 62929009, 1190778074, 657264006, 364156399, 775397332, 651143570, 486712236, 34309315, 1323491629, 1875163590, 1217887516, 2061463296, 24320578);
+            uint b3 = (2122131631);
+            uint4x4 r3 = uint4x4(3114434189, 3567091732, 3440188500, 2235764674, 3363613739, 2830099671, 2536992064, 2948232997, 2823979235, 2659547901, 2207144980, 3496327294, 4047999255, 3390723181, 4234298961, 2197156243);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_sub_scalar_wide()
+        {
+            uint a0 = (1691534405);
+            uint4x4 b0 = uint4x4(2022393810, 1612688515, 496689713, 887037586, 2097630964, 374934538, 939035482, 935242277, 1789300421, 264712893, 1231856067, 1818112748, 1428436109, 1258745460, 1077380396, 1330722719);
+            uint4x4 r0 = uint4x4(3964107891, 78845890, 1194844692, 804496819, 3888870737, 1316599867, 752498923, 756292128, 4197201280, 1426821512, 459678338, 4168388953, 263098296, 432788945, 614154009, 360811686);
+            TestUtils.AreEqual(a0 - b0, r0);
+
+            uint a1 = (518111829);
+            uint4x4 b1 = uint4x4(967128529, 344666254, 1082267918, 907866696, 1816885123, 460340568, 962154498, 557113461, 1701216709, 1980098777, 730060552, 1444397827, 853570556, 138836432, 1013190428, 718089530);
+            uint4x4 r1 = uint4x4(3845950596, 173445575, 3730811207, 3905212429, 2996194002, 57771261, 3850924627, 4255965664, 3111862416, 2832980348, 4083018573, 3368681298, 3959508569, 379275397, 3799888697, 4094989595);
+            TestUtils.AreEqual(a1 - b1, r1);
+
+            uint a2 = (506757390);
+            uint4x4 b2 = uint4x4(1216448041, 936312747, 1997286455, 1969982026, 902880656, 1161220697, 1442464725, 622960765, 730968909, 614823841, 1889779020, 918322352, 133929920, 213123108, 1835450460, 521068072);
+            uint4x4 r2 = uint4x4(3585276645, 3865411939, 2804438231, 2831742660, 3898844030, 3640503989, 3359259961, 4178763921, 4070755777, 4186900845, 2911945666, 3883402334, 372827470, 293634282, 2966274226, 4280656614);
+            TestUtils.AreEqual(a2 - b2, r2);
+
+            uint a3 = (2066839749);
+            uint4x4 b3 = uint4x4(1982717309, 1580139939, 136826185, 783667709, 205508687, 1152347947, 1682018862, 329924125, 396414255, 542319408, 208974930, 1638328097, 935729865, 125876461, 218665639, 1100023218);
+            uint4x4 r3 = uint4x4(84122440, 486699810, 1930013564, 1283172040, 1861331062, 914491802, 384820887, 1736915624, 1670425494, 1524520341, 1857864819, 428511652, 1131109884, 1940963288, 1848174110, 966816531);
+            TestUtils.AreEqual(a3 - b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mul_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(245827027, 208934650, 1019478917, 568231809, 877289039, 1585782440, 2111178729, 1186019069, 571481445, 1570087048, 629447153, 619383734, 2055121568, 700402816, 263414349, 187830569);
+            uint4x4 b0 = uint4x4(759663997, 350129201, 477450108, 1635735015, 388710278, 757722665, 1509388321, 1841703980, 1826369331, 1524322467, 1605207974, 428419155, 1460605791, 1968043860, 771161742, 2037340417);
+            uint4x4 r0 = uint4x4(3662155527, 1402281434, 332447596, 2361989735, 2624048730, 1455036648, 2128344329, 3700879228, 2640799263, 2093463192, 3087460678, 3161406466, 990589280, 3356793344, 2953243830, 1156600361);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x4 a1 = uint4x4(2048056680, 546694675, 853585367, 933370718, 990212476, 1915885905, 1984212358, 368146234, 899438811, 1765718681, 409003054, 2069758852, 140280263, 442491280, 1924530939, 1372320666);
+            uint4x4 b1 = uint4x4(322304267, 651448359, 1608326767, 1427155898, 1092185338, 665119139, 223634707, 694718952, 675813713, 999254223, 1326064110, 788102700, 1927999142, 1706356773, 747671596, 106127297);
+            uint4x4 r1 = uint4x4(649177976, 678952165, 1063621177, 2683284556, 2152538904, 3721713555, 2642853618, 1626072720, 1891467339, 335415735, 1128927428, 2638713520, 2861115658, 479369680, 3928339236, 4044803354);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x4 a2 = uint4x4(200879709, 857149632, 962693646, 988118613, 892998613, 534109991, 1836805716, 591690444, 1092459557, 1068605049, 1152926708, 1628337363, 400029062, 511168096, 1165835487, 1650108606);
+            uint4x4 b2 = uint4x4(1695925670, 1788874462, 534570710, 1110638325, 142931150, 1684745462, 2101748242, 1831486861, 5683864, 1735084283, 1336059993, 721992570, 1906075622, 1073069872, 1374497592, 242540880);
+            uint4x4 r2 = uint4x4(48406862, 2297104000, 4019846068, 2811510105, 293009766, 3677102970, 1179445736, 3813187164, 2708838392, 1397450915, 487571412, 3889286542, 326598756, 995119616, 638698952, 1153153376);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x4 a3 = uint4x4(1867348319, 464239430, 1513968722, 1879508953, 1835178747, 106255610, 791954119, 1098780631, 1336308698, 613897216, 1826550194, 1100684236, 67588307, 1388845400, 23402614, 2092286485);
+            uint4x4 b3 = uint4x4(1809758608, 288286688, 726755419, 364868101, 655080356, 266071904, 385013390, 186015668, 758488066, 1918847075, 1784720030, 1012303363, 135157062, 1204101671, 2062532388, 1665984668);
+            uint4x4 r3 = uint4x4(2376854640, 2027161408, 1912621350, 4186491197, 2728396, 1647526848, 418210914, 1845357612, 1544011700, 3794107392, 2497273820, 468065124, 2338334898, 412191848, 2980149912, 1944145100);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mul_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(1762033447, 465343930, 1570757881, 1326409563, 1824319147, 1356578909, 72749215, 154616909, 975743632, 573770299, 1958912969, 971327747, 1818877398, 1324050764, 660611671, 1279757657);
+            uint b0 = (1476837906);
+            uint4x4 r0 = uint4x4(2981789374, 1326807828, 2156411778, 4018813542, 4229418502, 2976383114, 2455742766, 2574460778, 1736252960, 2595843622, 2760103458, 2441439286, 2626798860, 2317418328, 1423071262, 2117820994);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint4x4 a1 = uint4x4(391009467, 890343818, 800117742, 606927173, 1338014500, 1688964615, 1439447294, 387721300, 1192501703, 1613845584, 76318055, 124378112, 970518733, 1370700538, 1978842602, 1451974062);
+            uint b1 = (1186856590);
+            uint4x4 r1 = uint4x4(1435732410, 218605196, 1896985092, 2520103494, 4169532920, 3544103394, 3210322148, 2141566616, 3231264354, 1813259360, 2572759330, 2432698368, 714733494, 209765036, 1993704396, 95853188);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint4x4 a2 = uint4x4(987919119, 1325430351, 948943118, 1743760648, 227492421, 217698851, 370371313, 309869840, 1389753586, 1895557060, 1449787207, 1817244670, 2117623142, 1951266912, 206918942, 382686790);
+            uint b2 = (1659987051);
+            uint4x4 r2 = uint4x4(548860741, 3519500037, 1518981338, 88896088, 1840817879, 997425313, 3200571067, 1277937072, 1861085478, 3612765932, 98332333, 3544396586, 3205554594, 2751221792, 438848394, 2319607618);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint4x4 a3 = uint4x4(396984449, 352046491, 1513331645, 1155106274, 138823406, 923862962, 131310587, 938688263, 631817444, 1890216972, 2143914807, 30238797, 5224899, 1350553408, 2127554014, 1666837332);
+            uint b3 = (474729765);
+            uint4x4 r3 = uint4x4(3912359845, 3698513511, 2844449617, 349983658, 1219417702, 1371907770, 443527751, 447592195, 903547124, 3098229180, 2847484403, 3116678177, 2741501999, 3006215232, 1864957718, 2131576612);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mul_scalar_wide()
+        {
+            uint a0 = (99541948);
+            uint4x4 b0 = uint4x4(1764461774, 657072478, 1459784358, 1610646683, 1632058826, 868441654, 1408757883, 335917146, 2105124483, 1178393968, 1963904348, 1409533767, 243286231, 1336308795, 517963367, 1733623488);
+            uint4x4 r0 = uint4x4(3344568648, 4192918280, 1260585960, 1158730452, 4293361240, 3828814248, 2108402516, 1966690328, 1623617844, 2603413056, 3464455056, 3011267876, 3666887396, 1294445652, 1610098852, 3603911936);
+            TestUtils.AreEqual(a0 * b0, r0);
+
+            uint a1 = (459880225);
+            uint4x4 b1 = uint4x4(994616533, 1420531535, 1821413700, 677771573, 2132626845, 1158827713, 640102997, 944551639, 1323243330, 1186460236, 657101857, 1275563580, 1031291523, 1008470115, 1155301041, 1046199281);
+            uint4x4 r1 = uint4x4(1378091637, 738687535, 3468449220, 3949757141, 316193853, 2121309665, 4072325109, 1750778551, 2563976578, 133205964, 1859727169, 388250044, 3682973667, 2802145731, 3778894801, 1074594065);
+            TestUtils.AreEqual(a1 * b1, r1);
+
+            uint a2 = (2138825098);
+            uint4x4 b2 = uint4x4(1273008873, 1788343477, 1994364082, 597340263, 2022856151, 1375763101, 1007501105, 1162446628, 96412054, 1676576573, 1763698296, 729299033, 1534484, 1053621089, 1978013043, 796620370);
+            uint4x4 r2 = uint4x4(1965095578, 1643380370, 1438423540, 15376006, 2208382182, 1819612578, 2939756906, 3283451240, 2728325340, 3233842146, 4167677104, 1377278202, 2222375624, 3926573898, 572695294, 2733759028);
+            TestUtils.AreEqual(a2 * b2, r2);
+
+            uint a3 = (890235481);
+            uint4x4 b3 = uint4x4(1880345584, 1882904983, 267128787, 1569254022, 1779318576, 1645728412, 819681361, 666095044, 308815496, 1829465065, 751656026, 1207837213, 1073832960, 169923853, 808603307, 363334486);
+            uint4x4 r3 = uint4x4(2992326256, 3526536063, 3957677659, 651297942, 2290472880, 2213466172, 1824177705, 3390288164, 56997192, 3913448961, 1427464010, 1396399637, 1642316800, 3035296645, 3228215155, 2580712678);
+            TestUtils.AreEqual(a3 * b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_div_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1590198532, 507812502, 126627032, 1058247011, 427387861, 290676154, 1829594484, 1127868739, 499016351, 1341209632, 134906097, 785470242, 788249865, 1099825433, 1552968283, 1822367139);
+            uint4x4 b0 = uint4x4(1434703236, 911965201, 390415521, 128746927, 525835375, 816946613, 878264647, 146789678, 2089524057, 254213018, 1916850021, 1737806518, 1906634983, 437754923, 825037958, 902508708);
+            uint4x4 r0 = uint4x4(1, 0, 0, 8, 0, 0, 2, 7, 0, 5, 0, 0, 0, 2, 1, 2);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x4 a1 = uint4x4(1021812060, 1937073018, 645757349, 1097576782, 1246027674, 1152153253, 1900577195, 172149343, 1735128704, 816492592, 2012272185, 632330092, 649232994, 123715336, 1438073735, 723262291);
+            uint4x4 b1 = uint4x4(896853614, 49452028, 1921327824, 787000669, 1032149621, 858558868, 1422112429, 837098844, 616122946, 2035322800, 1324534444, 1820832158, 917489631, 367475696, 620492088, 1749833550);
+            uint4x4 r1 = uint4x4(1, 39, 0, 1, 1, 1, 1, 0, 2, 0, 1, 0, 0, 0, 2, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x4 a2 = uint4x4(850951883, 1942618200, 1088675276, 1648515976, 991947275, 1155668991, 764696768, 1984712970, 1734485640, 850109866, 8545366, 1037720170, 264523522, 1547702681, 1797612488, 1496410581);
+            uint4x4 b2 = uint4x4(1535651093, 932740870, 1078416711, 725172174, 554208963, 1250240123, 2074395021, 1513621083, 262726589, 936845337, 1934527986, 1844761263, 116240860, 1875751365, 730101086, 625535586);
+            uint4x4 r2 = uint4x4(0, 2, 1, 2, 1, 0, 0, 1, 6, 0, 0, 0, 2, 0, 2, 2);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x4 a3 = uint4x4(308887330, 7606985, 1626977876, 1895907215, 1115090617, 1043375525, 168865453, 1056135390, 1080260308, 780473703, 1917865869, 1741288184, 497930923, 668217348, 1678197677, 1075043333);
+            uint4x4 b3 = uint4x4(1549803350, 364926102, 1386892120, 656711993, 91320418, 1458063222, 1529573616, 722321620, 757577900, 1175347146, 1933900601, 1063907544, 97856937, 972434416, 1920248258, 261846189);
+            uint4x4 r3 = uint4x4(0, 0, 1, 2, 12, 0, 0, 1, 1, 0, 0, 1, 5, 0, 0, 4);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_div_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(560951562, 1218680769, 375341724, 1613542090, 1919409166, 1397425408, 1349573078, 524526253, 341995568, 495895326, 1515313790, 1676971657, 2131487088, 2105094094, 1017891310, 542666029);
+            uint b0 = (947861580);
+            uint4x4 r0 = uint4x4(0, 1, 0, 1, 2, 1, 1, 0, 0, 0, 1, 1, 2, 2, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint4x4 a1 = uint4x4(1646044372, 107215658, 19616726, 896899915, 707389627, 1249475421, 1486968988, 1738891885, 1919705924, 1244966864, 1200843642, 206442634, 1508567412, 1825701056, 1117255783, 929925156);
+            uint b1 = (1447236569);
+            uint4x4 r1 = uint4x4(1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint4x4 a2 = uint4x4(1725332114, 1383839785, 2136282541, 159847918, 1515555001, 614923813, 1033495687, 1947230231, 1969254260, 1948672400, 757256792, 2099218773, 455629883, 324433498, 1679339858, 2024651647);
+            uint b2 = (1949103348);
+            uint4x4 r2 = uint4x4(0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint4x4 a3 = uint4x4(1222061694, 1966139194, 1303421248, 1811535294, 240471953, 2116688995, 1035856383, 2022133852, 2147186889, 152458544, 148729436, 318083619, 980911803, 817677917, 398058007, 747046501);
+            uint b3 = (579280546);
+            uint4x4 r3 = uint4x4(2, 3, 2, 3, 0, 3, 1, 3, 3, 0, 0, 0, 1, 1, 0, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_div_scalar_wide()
+        {
+            uint a0 = (1161272038);
+            uint4x4 b0 = uint4x4(187325733, 1594107378, 2016183849, 1589343709, 388768753, 1417077283, 1773486938, 1154044032, 81831373, 1476877645, 653688843, 45756703, 631027637, 396671391, 784365696, 1250594097);
+            uint4x4 r0 = uint4x4(6, 0, 0, 0, 2, 0, 0, 1, 14, 0, 1, 25, 1, 2, 1, 0);
+            TestUtils.AreEqual(a0 / b0, r0);
+
+            uint a1 = (1818363859);
+            uint4x4 b1 = uint4x4(1653451772, 270557729, 48974453, 1796936382, 1427856423, 981056957, 1955700573, 705450043, 1054404890, 351914083, 131970646, 1320586926, 366944102, 1575786200, 257204865, 1582754309);
+            uint4x4 r1 = uint4x4(1, 6, 37, 1, 1, 1, 0, 2, 1, 5, 13, 1, 4, 1, 7, 1);
+            TestUtils.AreEqual(a1 / b1, r1);
+
+            uint a2 = (2114509003);
+            uint4x4 b2 = uint4x4(1266146708, 45105265, 2092444751, 407744534, 126616016, 1900058250, 523718813, 414718546, 1828540203, 860638950, 1827704212, 182494419, 669579562, 717750865, 560379939, 681272719);
+            uint4x4 r2 = uint4x4(1, 46, 1, 5, 16, 1, 4, 5, 1, 2, 1, 11, 3, 2, 3, 3);
+            TestUtils.AreEqual(a2 / b2, r2);
+
+            uint a3 = (638134699);
+            uint4x4 b3 = uint4x4(297472499, 1196796276, 815483831, 1511819303, 906952957, 613050421, 60483276, 883893666, 1481847510, 1065163200, 1641516292, 1980940753, 1862370918, 2048575092, 396483978, 610486041);
+            uint4x4 r3 = uint4x4(2, 0, 0, 0, 0, 1, 10, 0, 0, 0, 0, 0, 0, 0, 1, 1);
+            TestUtils.AreEqual(a3 / b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mod_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(146150818, 1846543305, 1071447756, 308965362, 659881575, 1002365460, 861198439, 1510617532, 778525078, 1458458044, 101987897, 1249565173, 938026607, 1692541775, 1518877124, 1806965510);
+            uint4x4 b0 = uint4x4(983050390, 771341152, 942375212, 367361754, 749500619, 750718852, 2095151755, 88438806, 769227442, 647214624, 1026513788, 1544950956, 160166322, 1099108075, 1158422232, 1798905209);
+            uint4x4 r0 = uint4x4(146150818, 303861001, 129072544, 308965362, 659881575, 251646608, 861198439, 7157830, 9297636, 164028796, 101987897, 1249565173, 137194997, 593433700, 360454892, 8060301);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x4 a1 = uint4x4(1325139851, 994457255, 1372400564, 1770508529, 100255877, 452674793, 1545968777, 629019189, 1402964707, 2138294579, 1641714420, 1782022072, 1880968864, 1980798192, 1397317084, 995968277);
+            uint4x4 b1 = uint4x4(164686701, 327889784, 1082162785, 1213537518, 608481038, 329133821, 1824387961, 1223426748, 798137669, 79717779, 1233582258, 1267120677, 301592349, 911281434, 1357340934, 1648942990);
+            uint4x4 r1 = uint4x4(7646243, 10787903, 290237779, 556971011, 100255877, 123540972, 1545968777, 629019189, 604827038, 65632325, 408132162, 514901395, 71414770, 158235324, 39976150, 995968277);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x4 a2 = uint4x4(1090018756, 1573062648, 1100694500, 863521889, 1146202560, 546958747, 573838995, 2146465826, 1678630780, 1843627015, 1167611300, 157190789, 530148276, 594404567, 1248848240, 1963704081);
+            uint4x4 b2 = uint4x4(1350943898, 696511738, 1182727748, 1843845940, 244920526, 1640990506, 920431352, 1261122293, 469115027, 720739455, 1727247731, 91557593, 1874820225, 1070808215, 859227095, 890398590);
+            uint4x4 r2 = uint4x4(1090018756, 180039172, 1100694500, 863521889, 166520456, 546958747, 573838995, 885343533, 271285699, 402148105, 1167611300, 65633196, 530148276, 594404567, 389621145, 182906901);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x4 a3 = uint4x4(1759996408, 1386598712, 251325313, 122732248, 2082099427, 1080998866, 686623511, 693281682, 302610170, 1380134301, 1661197566, 481331690, 1193753109, 166363462, 588323181, 594997700);
+            uint4x4 b3 = uint4x4(951215450, 195024879, 2079991098, 220236959, 294448639, 1396793894, 141031566, 960537512, 719675899, 928202057, 275228822, 1510254672, 1481505055, 1373357922, 1940197321, 286975465);
+            uint4x4 r3 = uint4x4(808780958, 21424559, 251325313, 122732248, 20958954, 1080998866, 122497247, 693281682, 302610170, 451932244, 9824634, 481331690, 1193753109, 166363462, 588323181, 21046770);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mod_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(164800505, 1062177828, 1898749675, 1701653318, 820393245, 19002208, 128329633, 1464010899, 896587769, 405208598, 1982762194, 959236935, 712321026, 172564850, 1540068445, 1085897743);
+            uint b0 = (883951171);
+            uint4x4 r0 = uint4x4(164800505, 178226657, 130847333, 817702147, 820393245, 19002208, 128329633, 580059728, 12636598, 405208598, 214859852, 75285764, 712321026, 172564850, 656117274, 201946572);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint4x4 a1 = uint4x4(1607489717, 647846716, 915707999, 1602830401, 928191283, 1084934806, 488509689, 2087820912, 377501313, 1778384846, 1216011754, 812183417, 1153802502, 1642671870, 1924710742, 665297470);
+            uint b1 = (165478511);
+            uint4x4 r1 = uint4x4(118183118, 151411183, 88315444, 113523802, 100798728, 92063740, 157552667, 102078780, 46544291, 123599736, 57662177, 150269373, 160931436, 153365271, 104447121, 3383426);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint4x4 a2 = uint4x4(1568090825, 435886407, 453990946, 1731665372, 586777590, 1475597526, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 2130346558, 666621411);
+            uint b2 = (2050982942);
+            uint4x4 r2 = uint4x4(1568090825, 435886407, 453990946, 1731665372, 586777590, 1475597526, 1585649515, 1414579860, 1891664981, 1262495021, 1400758118, 1529532008, 430295164, 1386414018, 79363616, 666621411);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint4x4 a3 = uint4x4(1524342239, 1547690684, 857915601, 709453751, 2103243535, 2124726669, 1410239986, 1761316053, 442891932, 388101009, 1059801526, 651827482, 1890268914, 910020375, 58051452, 293939465);
+            uint b3 = (1490592900);
+            uint4x4 r3 = uint4x4(33749339, 57097784, 857915601, 709453751, 612650635, 634133769, 1410239986, 270723153, 442891932, 388101009, 1059801526, 651827482, 399676014, 910020375, 58051452, 293939465);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_mod_scalar_wide()
+        {
+            uint a0 = (242383789);
+            uint4x4 b0 = uint4x4(740000543, 1556450291, 1104736385, 437976569, 1911837205, 1507212038, 1906405167, 247693265, 293460573, 1495295166, 873323603, 530681233, 1298102643, 2057984657, 1000742091, 1461372131);
+            uint4x4 r0 = uint4x4(242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789, 242383789);
+            TestUtils.AreEqual(a0 % b0, r0);
+
+            uint a1 = (1859742342);
+            uint4x4 b1 = uint4x4(797184687, 821888842, 1083192997, 840114986, 1894865954, 615159964, 1485575122, 2028738, 2122220318, 164578061, 730088119, 1444946139, 1305792037, 1110829011, 872723581, 166847388);
+            uint4x4 r1 = uint4x4(265372968, 215964658, 776549345, 179512370, 1859742342, 14262450, 374167220, 1418334, 1859742342, 49383671, 399566104, 414796203, 553950305, 748913331, 114295180, 24421074);
+            TestUtils.AreEqual(a1 % b1, r1);
+
+            uint a2 = (1477846418);
+            uint4x4 b2 = uint4x4(511428733, 1642227542, 1962310765, 207128894, 1342085447, 448361286, 334667519, 705465751, 753088773, 1146344010, 275140144, 1074480141, 2092749846, 1631900558, 2088387496, 1098441751);
+            uint4x4 r2 = uint4x4(454988952, 1477846418, 1477846418, 27944160, 135760971, 132762560, 139176342, 66914916, 724757645, 331502408, 102145698, 403366277, 1477846418, 1477846418, 1477846418, 379404667);
+            TestUtils.AreEqual(a2 % b2, r2);
+
+            uint a3 = (1648646354);
+            uint4x4 b3 = uint4x4(1730303822, 859376331, 889118656, 1549752450, 992618236, 941290327, 1766644910, 435947831, 1937100534, 1342633977, 1176317048, 950230773, 1135152183, 384466155, 600022, 363833845);
+            uint4x4 r3 = uint4x4(1648646354, 789270023, 759527698, 98893904, 656028118, 707356027, 1648646354, 340802861, 1648646354, 306012377, 472329306, 698415581, 513494171, 110781734, 385920, 193310974);
+            TestUtils.AreEqual(a3 % b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_plus()
+        {
+            uint4x4 a0 = uint4x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926);
+            uint4x4 r0 = uint4x4(1643476803, 907898539, 379615839, 1140483021, 1735287433, 1743199272, 1472881565, 339091479, 401565897, 1287765427, 849339193, 174532915, 1864850812, 1566098441, 1145639744, 1615499926);
+            TestUtils.AreEqual(+a0, r0);
+
+            uint4x4 a1 = uint4x4(2049663954, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393);
+            uint4x4 r1 = uint4x4(2049663954, 409076474, 591286416, 1706631096, 1079164488, 1808261782, 1201290141, 82958939, 308695413, 1575280693, 2067379018, 1673126612, 500666137, 640289062, 836003812, 336058393);
+            TestUtils.AreEqual(+a1, r1);
+
+            uint4x4 a2 = uint4x4(829347661, 381670450, 277507230, 361395485, 1012749225, 1204186973, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986);
+            uint4x4 r2 = uint4x4(829347661, 381670450, 277507230, 361395485, 1012749225, 1204186973, 2092803800, 1459040742, 531853559, 2093894901, 1589622197, 1559976318, 619729461, 731886792, 1441425968, 1921783986);
+            TestUtils.AreEqual(+a2, r2);
+
+            uint4x4 a3 = uint4x4(1257555634, 578585280, 1087392044, 2084329354, 300198860, 1247120404, 1325809345, 1057524082, 1426592020, 167918579, 1552986194, 813448514, 2048383407, 647476365, 13335381, 1985958169);
+            uint4x4 r3 = uint4x4(1257555634, 578585280, 1087392044, 2084329354, 300198860, 1247120404, 1325809345, 1057524082, 1426592020, 167918579, 1552986194, 813448514, 2048383407, 647476365, 13335381, 1985958169);
+            TestUtils.AreEqual(+a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_neg()
+        {
+            uint4x4 a0 = uint4x4(1955022112, 662160019, 370300775, 2141283773, 1004505619, 28153593, 33894270, 505708349, 1115028238, 1636274969, 694995093, 1542206286, 213087293, 243937487, 341522275, 841085242);
+            uint4x4 r0 = uint4x4(2339945184, 3632807277, 3924666521, 2153683523, 3290461677, 4266813703, 4261073026, 3789258947, 3179939058, 2658692327, 3599972203, 2752761010, 4081880003, 4051029809, 3953445021, 3453882054);
+            TestUtils.AreEqual(-a0, r0);
+
+            uint4x4 a1 = uint4x4(574159094, 2057919693, 1175014732, 1259809073, 1212465326, 1190569920, 2047955772, 2120729864, 1440774928, 1485596454, 431666091, 1387601718, 1745651998, 319115626, 1119959806, 739132284);
+            uint4x4 r1 = uint4x4(3720808202, 2237047603, 3119952564, 3035158223, 3082501970, 3104397376, 2247011524, 2174237432, 2854192368, 2809370842, 3863301205, 2907365578, 2549315298, 3975851670, 3175007490, 3555835012);
+            TestUtils.AreEqual(-a1, r1);
+
+            uint4x4 a2 = uint4x4(1954173314, 1836511050, 1662806453, 506144868, 650922971, 1755382554, 1273997249, 1474445187, 1853826947, 1695573773, 729452512, 345069360, 575867536, 594119038, 1201840609, 1342872551);
+            uint4x4 r2 = uint4x4(2340793982, 2458456246, 2632160843, 3788822428, 3644044325, 2539584742, 3020970047, 2820522109, 2441140349, 2599393523, 3565514784, 3949897936, 3719099760, 3700848258, 3093126687, 2952094745);
+            TestUtils.AreEqual(-a2, r2);
+
+            uint4x4 a3 = uint4x4(1768435578, 23008237, 1410502890, 695213039, 1342131852, 1619073746, 469828650, 20553909, 1711214338, 690040786, 1749711826, 1265590278, 1516859887, 1317159343, 1722518934, 803074002);
+            uint4x4 r3 = uint4x4(2526531718, 4271959059, 2884464406, 3599754257, 2952835444, 2675893550, 3825138646, 4274413387, 2583752958, 3604926510, 2545255470, 3029377018, 2778107409, 2977807953, 2572448362, 3491893294);
+            TestUtils.AreEqual(-a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_prefix_inc()
+        {
+            uint4x4 a0 = uint4x4(864455342, 2035793213, 1275443862, 971919915, 411610189, 446210725, 395072276, 115573442, 913293639, 432884105, 1208161871, 1385544935, 1835605516, 831396561, 388229350, 696475402);
+            uint4x4 r0 = uint4x4(864455343, 2035793214, 1275443863, 971919916, 411610190, 446210726, 395072277, 115573443, 913293640, 432884106, 1208161872, 1385544936, 1835605517, 831396562, 388229351, 696475403);
+            TestUtils.AreEqual(++a0, r0);
+
+            uint4x4 a1 = uint4x4(1786514683, 752093909, 1622410417, 1398865015, 241906003, 1705625817, 609525897, 172599489, 504806865, 519296647, 281942776, 1541894135, 924683935, 259568871, 1349062584, 1120518661);
+            uint4x4 r1 = uint4x4(1786514684, 752093910, 1622410418, 1398865016, 241906004, 1705625818, 609525898, 172599490, 504806866, 519296648, 281942777, 1541894136, 924683936, 259568872, 1349062585, 1120518662);
+            TestUtils.AreEqual(++a1, r1);
+
+            uint4x4 a2 = uint4x4(65514038, 1321109497, 1366348660, 1777734111, 1414867743, 536776365, 539531120, 886558347, 1733014170, 1586973907, 1145067277, 884064327, 82551838, 1001250037, 924273925, 242241802);
+            uint4x4 r2 = uint4x4(65514039, 1321109498, 1366348661, 1777734112, 1414867744, 536776366, 539531121, 886558348, 1733014171, 1586973908, 1145067278, 884064328, 82551839, 1001250038, 924273926, 242241803);
+            TestUtils.AreEqual(++a2, r2);
+
+            uint4x4 a3 = uint4x4(413165245, 1206806909, 2069192976, 1613073974, 1342402025, 330167396, 665917965, 799320426, 2054286971, 2074397725, 113129500, 721162954, 2136093351, 173315234, 2006582934, 265026274);
+            uint4x4 r3 = uint4x4(413165246, 1206806910, 2069192977, 1613073975, 1342402026, 330167397, 665917966, 799320427, 2054286972, 2074397726, 113129501, 721162955, 2136093352, 173315235, 2006582935, 265026275);
+            TestUtils.AreEqual(++a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_postfix_inc()
+        {
+            uint4x4 a0 = uint4x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778);
+            uint4x4 r0 = uint4x4(1751003569, 2063707595, 1500486291, 969189211, 1007848192, 2028651936, 1643023524, 1190630527, 1396179607, 708474528, 177416855, 1524860667, 1408994706, 375284401, 1580130369, 1676086778);
+            TestUtils.AreEqual(a0++, r0);
+
+            uint4x4 a1 = uint4x4(717006530, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403);
+            uint4x4 r1 = uint4x4(717006530, 732199129, 2026873940, 130175844, 1513142653, 420613464, 1219979307, 586574160, 357567451, 1468020171, 1949784665, 1127356901, 101238629, 2131648021, 423320704, 827539403);
+            TestUtils.AreEqual(a1++, r1);
+
+            uint4x4 a2 = uint4x4(1919960927, 2010345998, 1047836590, 586887730, 1209169651, 1051531454, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320);
+            uint4x4 r2 = uint4x4(1919960927, 2010345998, 1047836590, 586887730, 1209169651, 1051531454, 1479717664, 1874959449, 104723114, 817246348, 1972950889, 1784631804, 1550936382, 718649502, 872906800, 717529320);
+            TestUtils.AreEqual(a2++, r2);
+
+            uint4x4 a3 = uint4x4(1995020676, 183815949, 1207670946, 1620827725, 1809811548, 1643094131, 280506984, 382615051, 650280741, 560631765, 1840722506, 63273626, 1294940978, 724310154, 1901579798, 697321264);
+            uint4x4 r3 = uint4x4(1995020676, 183815949, 1207670946, 1620827725, 1809811548, 1643094131, 280506984, 382615051, 650280741, 560631765, 1840722506, 63273626, 1294940978, 724310154, 1901579798, 697321264);
+            TestUtils.AreEqual(a3++, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_prefix_dec()
+        {
+            uint4x4 a0 = uint4x4(200904609, 871077500, 968578728, 638967721, 1995396216, 435367037, 1782514098, 1589827826, 1434377580, 596759698, 1699290403, 1758478358, 1914114460, 71237375, 389120307, 1022184392);
+            uint4x4 r0 = uint4x4(200904608, 871077499, 968578727, 638967720, 1995396215, 435367036, 1782514097, 1589827825, 1434377579, 596759697, 1699290402, 1758478357, 1914114459, 71237374, 389120306, 1022184391);
+            TestUtils.AreEqual(--a0, r0);
+
+            uint4x4 a1 = uint4x4(1310293956, 18299409, 906734601, 799006218, 1383897383, 1040798388, 1469596990, 1719228297, 220897829, 1454322707, 678025545, 14227726, 293093918, 1065286595, 1249415499, 1009503100);
+            uint4x4 r1 = uint4x4(1310293955, 18299408, 906734600, 799006217, 1383897382, 1040798387, 1469596989, 1719228296, 220897828, 1454322706, 678025544, 14227725, 293093917, 1065286594, 1249415498, 1009503099);
+            TestUtils.AreEqual(--a1, r1);
+
+            uint4x4 a2 = uint4x4(157482354, 1797304434, 1083672612, 929765380, 2083512379, 2045544045, 323646560, 1395297406, 583796119, 999841714, 1788073019, 1618852114, 1777032041, 1252764958, 1070818447, 219340317);
+            uint4x4 r2 = uint4x4(157482353, 1797304433, 1083672611, 929765379, 2083512378, 2045544044, 323646559, 1395297405, 583796118, 999841713, 1788073018, 1618852113, 1777032040, 1252764957, 1070818446, 219340316);
+            TestUtils.AreEqual(--a2, r2);
+
+            uint4x4 a3 = uint4x4(767990877, 366067423, 99249400, 1549382038, 1105868582, 1977762759, 1646465385, 1067223071, 1774498387, 1128527977, 1104488553, 1575600100, 1141283662, 1678956750, 449874904, 748975258);
+            uint4x4 r3 = uint4x4(767990876, 366067422, 99249399, 1549382037, 1105868581, 1977762758, 1646465384, 1067223070, 1774498386, 1128527976, 1104488552, 1575600099, 1141283661, 1678956749, 449874903, 748975257);
+            TestUtils.AreEqual(--a3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_postfix_dec()
+        {
+            uint4x4 a0 = uint4x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868);
+            uint4x4 r0 = uint4x4(283970262, 1109329936, 1073216143, 649439137, 1932646215, 1174104498, 484207852, 524156737, 691209285, 2017728859, 802721301, 377162390, 526366486, 1504625034, 590919177, 60677868);
+            TestUtils.AreEqual(a0--, r0);
+
+            uint4x4 a1 = uint4x4(1867810045, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911);
+            uint4x4 r1 = uint4x4(1867810045, 670715645, 324944916, 242636153, 1659736954, 1316734088, 1030072405, 1751972064, 1868889881, 1726583208, 1931943579, 175622377, 181847458, 665549439, 530897466, 635466911);
+            TestUtils.AreEqual(a1--, r1);
+
+            uint4x4 a2 = uint4x4(416440036, 1444496274, 296146626, 1209855130, 2016700604, 838640502, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298);
+            uint4x4 r2 = uint4x4(416440036, 1444496274, 296146626, 1209855130, 2016700604, 838640502, 647102652, 1948542169, 659874422, 2009120584, 1577004911, 1809041177, 518526567, 1464738365, 1815629310, 1216839298);
+            TestUtils.AreEqual(a2--, r2);
+
+            uint4x4 a3 = uint4x4(569144612, 509007463, 860240975, 41334109, 10321636, 1940079495, 43143738, 1044950720, 63756334, 1595004937, 699747920, 348534360, 509361827, 1352179420, 271823835, 1889179126);
+            uint4x4 r3 = uint4x4(569144612, 509007463, 860240975, 41334109, 10321636, 1940079495, 43143738, 1044950720, 63756334, 1595004937, 699747920, 348534360, 509361827, 1352179420, 271823835, 1889179126);
+            TestUtils.AreEqual(a3--, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_and_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(779935043, 1097962163, 1939593304, 800599247, 952140918, 782792558, 1608557706, 396446406, 2039894114, 1286974642, 442394124, 1759739564, 233435438, 665207770, 1942050241, 1022352952);
+            uint4x4 b0 = uint4x4(307705143, 1710882162, 866836769, 532490608, 679371720, 1794035877, 1439832202, 519529812, 23633139, 1209152681, 646737179, 1255867027, 1900854122, 413173763, 1409138251, 2087190272);
+            uint4x4 r0 = uint4x4(39064835, 1097961522, 864731136, 263727168, 675283008, 715673636, 1438646410, 379666500, 16781410, 1209017504, 34366472, 1220739712, 21541162, 10485762, 1405162561, 1013440000);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x4 a1 = uint4x4(60340400, 329119345, 406517382, 1126764634, 343425836, 1957552749, 1624478957, 341972372, 181537307, 130347414, 1240828622, 526120460, 695449226, 1477446724, 201628999, 737924014);
+            uint4x4 b1 = uint4x4(563439483, 354579077, 642224854, 1650432515, 755290290, 902865191, 661389406, 2134212586, 1855189321, 185194029, 810374380, 133197864, 1989578783, 38739182, 387425484, 1690486314);
+            uint4x4 r1 = uint4x4(26222640, 285241857, 168582, 1107890178, 67125280, 880844837, 541065292, 337646976, 177340425, 50384900, 4522188, 122712072, 538087434, 3140, 67404868, 549634602);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x4 a2 = uint4x4(1804502415, 1733695477, 1110712857, 113012430, 1044352152, 865726845, 836668077, 1778871717, 1558881750, 231636456, 1278790837, 846361650, 37319023, 1806613498, 1312261777, 1448803516);
+            uint4x4 b2 = uint4x4(843085933, 1045118223, 41867329, 1397669260, 1784025774, 1834587481, 856874373, 1719529679, 678478831, 86860920, 837158923, 1397449667, 195921481, 564422246, 1088025452, 2103483999);
+            uint4x4 r2 = uint4x4(570425357, 641864965, 36962305, 34352268, 706085000, 555323737, 823298181, 1644519557, 140542406, 84698216, 2099201, 306339842, 36241481, 564404834, 1074889216, 1413520412);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x4 a3 = uint4x4(17366276, 1245846423, 1075177576, 1023499729, 1742176891, 1288325524, 2092131182, 1444013434, 210707066, 627341079, 155789028, 411695477, 2144207930, 1007799200, 382737478, 85407483);
+            uint4x4 b3 = uint4x4(267066435, 781393024, 1444337796, 139669978, 880161801, 1604286495, 839016626, 1986058500, 1905400692, 1670633815, 651063094, 967343492, 336245810, 914791376, 1696073831, 2103810347);
+            uint4x4 r3 = uint4x4(17308672, 167909504, 1075103744, 134287824, 609615881, 1284130836, 805462050, 1442889984, 8520304, 553668887, 4728356, 411597060, 336200754, 872450944, 68159558, 84217899);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_and_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(443615469, 490057985, 2042441263, 1524760558, 1405175110, 510212004, 1941875181, 1236735839, 1365509729, 428270198, 607982857, 650270920, 1249238550, 814629680, 1862276471, 143502472);
+            uint b0 = (93423598);
+            uint4x4 r0 = uint4x4(1114348, 85033216, 26281518, 8488942, 25232710, 67176356, 26247660, 26281806, 16778848, 25199206, 68224264, 75497672, 1148422, 8389408, 83887462, 8488072);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint4x4 a1 = uint4x4(861733033, 957693145, 1567715668, 1102952410, 322053683, 1599352836, 208656708, 1272226025, 462670926, 1817145060, 1466722981, 1817277774, 818900583, 772681077, 1630437952, 546018772);
+            uint b1 = (1408932942);
+            uint4x4 r1 = uint4x4(324534280, 286268488, 1366298692, 1102615626, 322044930, 1397755908, 6985796, 1137737800, 328371278, 1078594628, 1399326724, 1078989902, 281676870, 34212932, 1093304384, 9081924);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint4x4 a2 = uint4x4(872875431, 708719245, 1764446048, 1527981061, 398141788, 156911041, 554819377, 1683835293, 972562207, 393685571, 2118911919, 1503487659, 283854137, 1911282206, 312686024, 384581172);
+            uint b2 = (1143080525);
+            uint4x4 r2 = uint4x4(67240965, 2228749, 1075971648, 1073873925, 69337164, 132161, 1537, 1140850701, 2098701, 69337665, 1140852237, 1073743369, 2229257, 1075970572, 2229320, 69207556);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint4x4 a3 = uint4x4(1826788967, 3292432, 225233484, 1488146706, 1918853562, 1038188796, 1833784555, 252534533, 942504184, 840550591, 475152200, 1566941712, 546609146, 1803072768, 1125028552, 104252148);
+            uint b3 = (150752148);
+            uint4x4 r3 = uint4x4(148898308, 3148048, 141314564, 145768720, 6046096, 148897940, 139214976, 135023364, 137119888, 1591444, 139463424, 140771856, 9700240, 142082304, 787072, 3424916);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_and_scalar_wide()
+        {
+            uint a0 = (1144543590);
+            uint4x4 b0 = uint4x4(420346723, 562416448, 1393127318, 1560699552, 851218057, 703880958, 1159378889, 2031211279, 1089518981, 270607307, 1349288930, 520199596, 1763483957, 1248975349, 236938635, 185023291);
+            uint4x4 r0 = uint4x4(547170, 18752, 1074284806, 1140867104, 3672064, 3168358, 1142427968, 1074811142, 1076893956, 2097474, 1076363618, 67115300, 1075314980, 1076910436, 68698370, 6434);
+            TestUtils.AreEqual(a0 & b0, r0);
+
+            uint a1 = (1085233038);
+            uint4x4 b1 = uint4x4(1845693112, 946052961, 1436238522, 2042776519, 56356886, 1770159840, 1872339579, 1439201366, 1233066417, 1214109404, 2255485, 1814885263, 1711986588, 1286898282, 915476451, 1870138851);
+            uint4x4 r1 = uint4x4(1073939080, 2299648, 1082868362, 1082278790, 741382, 1082283648, 1082720778, 1082675206, 1076826496, 1074615948, 2245132, 1076646798, 1074419596, 1084490250, 8456066, 1076364674);
+            TestUtils.AreEqual(a1 & b1, r1);
+
+            uint a2 = (372814411);
+            uint4x4 b2 = uint4x4(1623486506, 211665304, 1668985777, 348112007, 1808619374, 1516730209, 1647041932, 350465899, 1641369007, 1555310928, 857924828, 1980404095, 34923708, 1073528483, 742357726, 1244015681);
+            uint4x4 r2 = uint4x4(12298, 68714504, 37270017, 339247107, 34083402, 304099905, 36212744, 337683019, 1048587, 338698304, 304128072, 369659979, 34643976, 372814339, 70791754, 35659841);
+            TestUtils.AreEqual(a2 & b2, r2);
+
+            uint a3 = (1980296380);
+            uint4x4 b3 = uint4x4(1295368015, 859181113, 1741688223, 1249250718, 363989837, 939740255, 1668271386, 121498186, 1765635287, 1637255201, 1157123404, 216326016, 1525016040, 1131192672, 433812479, 797544392);
+            uint4x4 r3 = uint4x4(1140894732, 838860856, 1711279260, 1107299484, 335546380, 805325852, 1644743704, 101246984, 1611162772, 1610647584, 1141394444, 67161216, 1375790248, 1107861536, 268984508, 638094472);
+            TestUtils.AreEqual(a3 & b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_or_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1731159103, 659068416, 382702471, 1821032196, 1565773438, 1004000514, 948501377, 600951835, 669346222, 396691477, 2108560248, 2117522137, 330307355, 818676817, 1774459567, 1117506257);
+            uint4x4 b0 = uint4x4(1583847161, 692672727, 1161585489, 1756207130, 1321374429, 1287357212, 2075767170, 1273513430, 1610830169, 1316929125, 511625048, 573925879, 1502255628, 1841676448, 1682928938, 1115131952);
+            uint4x4 r0 = uint4x4(2138044159, 793370327, 1476391895, 1823457054, 1607720703, 2147473182, 2075786115, 1811533279, 1743223295, 1610595957, 2147407736, 2117598207, 1538957087, 2110637297, 1842315183, 1124063985);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x4 a1 = uint4x4(1254511182, 1017865993, 1883021644, 1140203470, 759288967, 2122744307, 335621148, 715028074, 543305337, 662107399, 1934997335, 436754869, 1613808671, 362365372, 342908672, 2129231210);
+            uint4x4 b1 = uint4x4(1541423910, 1416096228, 188606371, 1041599540, 219545389, 560097663, 1087543661, 936383841, 108816721, 1694053551, 452638547, 1219534055, 85142537, 1027930490, 2126839395, 2030328147);
+            uint4x4 r1 = uint4x4(1541821294, 2096099309, 2067654639, 2146934782, 760610735, 2145839615, 1423162749, 1071544171, 645820281, 1744827823, 2080356183, 1522064887, 1697901599, 1037957630, 2129985379, 2146270587);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x4 a2 = uint4x4(203868172, 32846030, 1057901177, 1537975433, 470626699, 557640158, 536364388, 238304731, 787227554, 1298371111, 1020821539, 1327618264, 1104669041, 1949771204, 1973724646, 698690868);
+            uint4x4 b2 = uint4x4(2036352209, 1554561114, 1332339254, 480739851, 1502575584, 1889014859, 1557424474, 1390247341, 2029776623, 1665642846, 1570936353, 801872635, 1945815585, 1797879107, 112272980, 779933219);
+            uint4x4 r2 = uint4x4(2103889117, 1576909022, 2138040959, 1605346955, 1569684459, 1908211167, 1610378622, 1593671167, 2130702319, 1869067135, 2113574435, 1877727995, 1946151793, 2134865351, 2008393718, 805175095);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x4 a3 = uint4x4(237797826, 356229491, 1054697631, 2025966311, 718324935, 1223426852, 2042482036, 683169667, 1994321453, 240702936, 828468284, 1009506608, 708733945, 449892073, 1530051697, 654498852);
+            uint4x4 b3 = uint4x4(92416160, 446752586, 1307950607, 1358449730, 181367548, 432421751, 695223657, 56384197, 1119601678, 460615696, 463588364, 780415466, 1378457042, 1259569239, 1887579973, 358353719);
+            uint4x4 r3 = uint4x4(263104994, 532408187, 2147352223, 2029637351, 719320831, 1508785015, 2046676349, 737959879, 1996484143, 528283096, 1004661820, 1051720186, 2051014651, 1540607743, 2075311989, 928964407);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_or_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(961259683, 471103264, 1733389229, 1591585258, 386953869, 1148351449, 1048929715, 1814263250, 860336789, 1637162093, 1227888278, 774029856, 879300408, 1179087439, 797240690, 1977614655);
+            uint b0 = (1666102508);
+            uint4x4 r0 = uint4x4(2068823279, 2136930284, 1734344685, 2145369582, 2002712301, 1736374269, 2144335359, 1869608446, 1934604029, 1675607277, 1803466494, 1869543148, 2003812348, 1733293807, 1875836414, 2012132863);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint4x4 a1 = uint4x4(46921989, 284225881, 64304104, 313591807, 1393862490, 1890090886, 521303722, 2021379070, 2055963359, 1511253082, 1775629833, 1142751163, 1767274359, 1421981808, 1501294791, 485944015);
+            uint b1 = (1980838747);
+            uint4x4 r1 = uint4x4(1994128223, 1995567963, 2010461179, 1991325695, 1997911899, 1991868383, 2131982331, 2122054655, 2124133343, 2115237723, 2144728923, 1981677563, 2136438655, 1993456507, 2138829791, 2130181087);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint4x4 a2 = uint4x4(539526284, 1815369493, 529427586, 358352200, 1353013374, 1349149982, 1624839772, 1369983151, 666444298, 207757238, 257316089, 409252967, 1919967661, 1452040383, 2012115244, 1149949643);
+            uint b2 = (310877895);
+            uint4x4 r2 = uint4x4(850370255, 2125979607, 529530567, 400531407, 1386733311, 1391460319, 1927257823, 1404034799, 935313103, 518496247, 534241023, 451395303, 1928855535, 1452277503, 2012217327, 1452269263);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint4x4 a3 = uint4x4(142082352, 1052987078, 1551897284, 647667876, 272240018, 728496025, 1212085507, 1717689835, 478474157, 1784582014, 1420783529, 671512087, 1240546077, 215180285, 1874077134, 288085841);
+            uint b3 = (1760023655);
+            uint4x4 r3 = uint4x4(1761596791, 2129125095, 2095568615, 1862268135, 2030034423, 1810888703, 1761604967, 1860689391, 2095579119, 1795153791, 2096103407, 1760032375, 1777860479, 1828190207, 1878521327, 2045761399);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_or_scalar_wide()
+        {
+            uint a0 = (1213433101);
+            uint4x4 b0 = uint4x4(1212928242, 1614462616, 936937728, 764766995, 306352095, 574719481, 1283571271, 2109131012, 979469710, 1348323481, 1407542578, 697517649, 1059093741, 627815046, 418822515, 83214352);
+            uint4x4 r0 = uint4x4(1213978111, 1752940445, 2145094925, 1842867999, 1515425759, 1783858685, 1288945487, 2113391885, 2054391183, 1482673565, 1542972735, 1775486813, 2138308077, 1836824463, 1492630911, 1291306269);
+            TestUtils.AreEqual(a0 | b0, r0);
+
+            uint a1 = (424663473);
+            uint4x4 b1 = uint4x4(447949225, 527022375, 1947148461, 305251437, 1254601325, 1752329425, 1592402684, 1587055329, 1088734150, 298563808, 2052547661, 582843231, 656983670, 1944993640, 1081208038, 829763560);
+            uint4x4 r1 = uint4x4(469760441, 527432119, 2102393277, 461364733, 1540357117, 2038431217, 1609563133, 1608506353, 1508891639, 433060337, 2069888509, 1006631935, 1064296439, 2079326201, 1501560311, 964689913);
+            TestUtils.AreEqual(a1 | b1, r1);
+
+            uint a2 = (990961386);
+            uint4x4 b2 = uint4x4(547309556, 1307122961, 263229121, 1518227598, 1098359242, 997941952, 1075751132, 996271847, 623986648, 1091787263, 1548400620, 2022447724, 433714471, 963197960, 1639565037, 1287986616);
+            uint4x4 r2 = uint4x4(1000333310, 2147082235, 1068556011, 2071912174, 2071461866, 997981930, 2065628926, 997326575, 1060233210, 2064900095, 2136670190, 2073878254, 1004142575, 997850858, 2075778799, 2144722938);
+            TestUtils.AreEqual(a2 | b2, r2);
+
+            uint a3 = (1326199854);
+            uint4x4 b3 = uint4x4(1949398395, 2027606165, 1750615303, 908181664, 2105810564, 2009616838, 1492018691, 1325195313, 1365101592, 276155673, 1378507257, 1526287781, 322486040, 1550813488, 326334540, 2015237736);
+            uint4x4 r3 = uint4x4(2134734207, 2145318079, 1868330287, 2133718190, 2139897518, 2144105966, 1609463343, 1341977663, 1599994942, 1602092351, 1596882431, 1610448303, 1597816638, 1601158462, 1602190446, 2132686446);
+            TestUtils.AreEqual(a3 | b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_xor_wide_wide()
+        {
+            uint4x4 a0 = uint4x4(1556324760, 207002929, 1843444873, 1632079131, 1460334334, 1607815585, 220623650, 38668553, 47193340, 643663548, 1371932564, 94957188, 700973621, 370621508, 2087573076, 351476570);
+            uint4x4 b0 = uint4x4(1054997548, 1523759632, 251164872, 110472397, 384031112, 1109163205, 535118981, 179106262, 1523031711, 1713313372, 1294118730, 520360641, 1040688781, 1020757245, 1143954843, 1281933464);
+            uint4x4 r0 = uint4x4(1646419380, 1451501345, 1662567489, 1741824470, 1105803126, 499723620, 314783655, 149092575, 1477935715, 1078104288, 484747486, 447544389, 399484088, 717273273, 943885263, 1486609346);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x4 a1 = uint4x4(1340815927, 681577472, 314138777, 446857644, 1368661599, 1672499683, 1259759761, 2049102405, 1972524935, 91962333, 1960780785, 1303778459, 960040360, 822786011, 2028027011, 170382968);
+            uint4x4 b1 = uint4x4(175288469, 326874157, 1192052687, 1087083643, 1900865484, 1521193463, 569695524, 1622101483, 1340735463, 546583617, 1034420616, 262206030, 1834125935, 802756092, 611321886, 316379491);
+            uint4x4 r1 = uint4x4(1167690402, 1004255277, 1437869910, 1516836311, 551090579, 958119956, 1793242549, 445489070, 981182560, 636424092, 1232544377, 1108797141, 1416333255, 517186087, 1553020061, 419186459);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x4 a2 = uint4x4(32554542, 1915830925, 2001025156, 2012451132, 1076174067, 344651773, 1769102694, 1408084527, 1139070023, 1195715957, 1051992510, 1468636326, 1018993657, 1514317444, 369266676, 1206540279);
+            uint4x4 b2 = uint4x4(325882121, 45335181, 1859278043, 1002624300, 1704063552, 1618550727, 721247372, 131278097, 896003672, 746837613, 1952376600, 306395311, 419371442, 627496489, 1791585199, 757339713);
+            uint4x4 r2 = uint4x4(312225575, 1887600640, 429354079, 1278297104, 632614579, 1962141754, 1133445610, 1413386046, 1988311583, 1808202520, 1256900262, 1170908169, 608404043, 2133094573, 2093737051, 1791902134);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x4 a3 = uint4x4(1730482516, 1488638921, 801348246, 1768559974, 1475767978, 1617893197, 689768843, 640586983, 426041408, 1811169716, 1563089576, 1411870628, 1004729442, 1173825171, 344960599, 633357624);
+            uint4x4 b3 = uint4x4(1356120192, 933877640, 2003767224, 113246892, 1236821680, 256717233, 1832711379, 238792988, 691507914, 1132023339, 1571029002, 227661589, 1609435614, 1581653714, 1384954643, 1432072515);
+            uint4x4 r3 = uint4x4(938594772, 1863517249, 1487705390, 1873418186, 508430362, 1864509180, 1143078232, 672474619, 810775178, 680333215, 9362082, 1505147057, 1678572988, 464599105, 1174607172, 1889268859);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_xor_wide_scalar()
+        {
+            uint4x4 a0 = uint4x4(2124666952, 177397845, 574879617, 1937385541, 1136545648, 213863690, 535061373, 289301586, 1305234431, 353786540, 1308626970, 1267729267, 125659640, 1315625690, 1730088797, 116862046);
+            uint b0 = (493665894);
+            uint4x4 r0 = uint4x4(1674536494, 402546227, 1060063719, 1846973987, 1590882582, 299103084, 42523931, 206756404, 1352725913, 142271690, 1399631484, 1459404053, 437376926, 1392927932, 2054402363, 463180344);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint4x4 a1 = uint4x4(375757978, 191750702, 187129429, 967051293, 549951551, 653124416, 788984, 1479174924, 1680011736, 447453839, 890841598, 293394300, 527727631, 529042816, 1382138962, 1206186973);
+            uint b1 = (491079274);
+            uint4x4 r1 = uint4x4(186702576, 371762244, 375527487, 618745463, 1031986773, 1000908074, 491343762, 1164914022, 2036840370, 133094629, 677146516, 205099286, 36780645, 47041514, 1327792696, 1520547255);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint4x4 a2 = uint4x4(1059509471, 64097148, 1814786305, 716239, 476052372, 92561487, 2058208914, 41260658, 1316660543, 2113008061, 256229982, 111578612, 1207271814, 2099944258, 1913013312, 870798185);
+            uint b2 = (744733291);
+            uint4x4 r2 = uint4x4(323317428, 800174359, 1078512490, 745101220, 809255423, 703060516, 1456372985, 773205017, 1645813588, 1368542166, 589723701, 717567903, 1805007853, 1363747113, 1583742507, 528804098);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint4x4 a3 = uint4x4(1771744425, 1026064492, 275465401, 1157615659, 2091197990, 1671757076, 574090633, 458210617, 1604017559, 1913893498, 1791703422, 2143390933, 777506800, 1972227371, 2073971655, 61542294);
+            uint b3 = (75727457);
+            uint4x4 r3 = uint4x4(1830366920, 967508493, 350799576, 1081889354, 2015798343, 1730641781, 649359336, 533479256, 1528356854, 1989160987, 1850260255, 2067926708, 718556561, 1896763210, 2132658598, 120098295);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_xor_scalar_wide()
+        {
+            uint a0 = (1288453276);
+            uint4x4 b0 = uint4x4(1077599928, 884741329, 212164516, 1585020328, 152985454, 1775851275, 1416249064, 1309317737, 1773918217, 1509843030, 1206045972, 1154916424, 1947871003, 1774252400, 1946113778, 1079717492);
+            uint4x4 r0 = uint4x4(217506340, 2020616269, 1080648504, 313868596, 1171416050, 622160791, 413532788, 46573301, 628614293, 355622090, 187625864, 135961812, 953555847, 621596140, 1060334190, 211227368);
+            TestUtils.AreEqual(a0 ^ b0, r0);
+
+            uint a1 = (290620937);
+            uint4x4 b1 = uint4x4(1382343363, 939045099, 1309568053, 221134131, 885841718, 612068188, 194068085, 1396957881, 573581481, 1813817520, 86594349, 2006985393, 1431761813, 905646837, 1522414781, 192882943);
+            uint4x4 r1 = uint4x4(1127638218, 648689378, 1599924796, 477936442, 631134527, 891940181, 449034364, 1108436144, 862105248, 2102275769, 343659812, 1727179960, 1141142940, 615093500, 1273803444, 439201526);
+            TestUtils.AreEqual(a1 ^ b1, r1);
+
+            uint a2 = (714832744);
+            uint4x4 b2 = uint4x4(374210759, 215701593, 1573378082, 779254615, 711527976, 710611783, 223429246, 593102399, 1444947259, 302938485, 684673240, 1417651941, 1426772271, 948720266, 177752267, 2005602645);
+            uint4x4 r2 = uint4x4(1020623791, 641737521, 2002559818, 82378815, 15889728, 12609583, 667564310, 163675479, 2092654163, 949289501, 39072688, 2128928141, 2140252743, 303507938, 537080739, 1561356861);
+            TestUtils.AreEqual(a2 ^ b2, r2);
+
+            uint a3 = (896851285);
+            uint4x4 b3 = uint4x4(1187420887, 536338211, 874727301, 1067319145, 191758210, 272673141, 18096431, 188062447, 1726887620, 2109517402, 1329654715, 1449815991, 342156404, 604196193, 1831114838, 962033481);
+            uint4x4 r3 = uint4x4(1941063554, 713228918, 22518480, 183050812, 1041834711, 624194592, 878771322, 1044465594, 1402661777, 1221096207, 2050242286, 1662956258, 554711329, 293048372, 1481655555, 203663900);
+            TestUtils.AreEqual(a3 ^ b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_left_shift()
+        {
+            uint4x4 a0 = uint4x4(197771193, 622182602, 1283988958, 1327917304, 473415985, 432425717, 870301196, 2058433484, 1200694230, 1531607705, 1360008038, 1008296534, 1447702302, 1079614371, 35667343, 1664454606);
+            int b0 = (1321149625);
+            uint4x4 r0 = uint4x4(1912602624, 2483027968, 3154116608, 4026531840, 1644167168, 3925868544, 402653184, 2550136832, 2885681152, 838860800, 3422552064, 2885681152, 1006632960, 1174405120, 503316480, 2617245696);
+            TestUtils.AreEqual(a0 << b0, r0);
+
+            uint4x4 a1 = uint4x4(2045594989, 592678686, 297755411, 1722762487, 1161625759, 37265945, 997793693, 1521705181, 263886278, 221147365, 2084190583, 230910816, 71403448, 481375728, 1176038816, 1382694875);
+            int b1 = (2077023268);
+            uint4x4 r1 = uint4x4(2664748752, 892924384, 469119280, 1794396016, 1406142960, 596255120, 3079797200, 2872446416, 4222180448, 3538357840, 3282278256, 3694573056, 1142455168, 3407044352, 1636751872, 648281520);
+            TestUtils.AreEqual(a1 << b1, r1);
+
+            uint4x4 a2 = uint4x4(1824729613, 1581610518, 407677878, 1208958192, 740058147, 946058001, 880835937, 2063772405, 430594634, 281771991, 1130057990, 1127968177, 1628217625, 979935914, 17663275, 956738326);
+            int b2 = (1535276688);
+            uint4x4 r2 = uint4x4(705495040, 1981153280, 2880831488, 1022361600, 1680015360, 3004235776, 2103508992, 2868183040, 1514799104, 2144796672, 1359347712, 1840316416, 2702770176, 2729050112, 2234187776, 2870345728);
+            TestUtils.AreEqual(a2 << b2, r2);
+
+            uint4x4 a3 = uint4x4(1996060114, 542942787, 65869628, 622492353, 159523866, 584916657, 286195265, 1953695770, 209529707, 211278352, 933594260, 1827522668, 1129290782, 1050231977, 183969222, 1773085306);
+            int b3 = (927390277);
+            uint4x4 r3 = uint4x4(3744381504, 194300000, 2107828096, 2739886112, 809796416, 1537463840, 568313888, 2388722496, 2409983328, 2465939968, 4105212544, 2646150528, 1777566656, 3542652192, 1592047808, 904154944);
+            TestUtils.AreEqual(a3 << b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_right_shift()
+        {
+            uint4x4 a0 = uint4x4(548167301, 1161338299, 1617625829, 1860731847, 713958715, 196552656, 770466193, 1265099998, 572763124, 506619530, 426807581, 2031319045, 701927980, 917785020, 569504877, 185593382);
+            int b0 = (1266801540);
+            uint4x4 r0 = uint4x4(34260456, 72583643, 101101614, 116295740, 44622419, 12284541, 48154137, 79068749, 35797695, 31663720, 26675473, 126957440, 43870498, 57361563, 35594054, 11599586);
+            TestUtils.AreEqual(a0 >> b0, r0);
+
+            uint4x4 a1 = uint4x4(1102123711, 1624751550, 280138733, 1598620011, 1840564178, 736389149, 1279158873, 408822762, 763607760, 348013684, 1568185874, 774126687, 1587054000, 600069797, 29576474, 1880981389);
+            int b1 = (334005460);
+            uint4x4 r1 = uint4x4(1051, 1549, 267, 1524, 1755, 702, 1219, 389, 728, 331, 1495, 738, 1513, 572, 28, 1793);
+            TestUtils.AreEqual(a1 >> b1, r1);
+
+            uint4x4 a2 = uint4x4(352174824, 425441430, 186542511, 1099859381, 1234295294, 1028666766, 761662151, 1254855819, 903402043, 1180315725, 182990778, 958706431, 1075621082, 1409488892, 1576738052, 700893981);
+            int b2 = (1164508476);
+            uint4x4 r2 = uint4x4(1, 1, 0, 4, 4, 3, 2, 4, 3, 4, 0, 3, 4, 5, 5, 2);
+            TestUtils.AreEqual(a2 >> b2, r2);
+
+            uint4x4 a3 = uint4x4(1435331003, 1447204571, 494777716, 1097030937, 1573721009, 424949150, 338466956, 1451909085, 2097834602, 1996022619, 1349763966, 490973311, 1133192771, 2054033380, 397231107, 150337656);
+            int b3 = (1759616654);
+            uint4x4 r3 = uint4x4(87605, 88330, 30198, 66957, 96052, 25936, 20658, 88617, 128041, 121827, 82383, 29966, 69164, 125368, 24245, 9175);
+            TestUtils.AreEqual(a3 >> b3, r3);
+        }
+
+        [TestCompiler]
+        public static void uint4x4_operator_bitwise_not()
+        {
+            uint4x4 a0 = uint4x4(1403358969, 831360921, 2088190243, 976721016, 878283189, 308994339, 1935567517, 1420884856, 472965491, 771711426, 627580960, 2061524024, 753208488, 2097179283, 1303022493, 664744603);
+            uint4x4 r0 = uint4x4(2891608326, 3463606374, 2206777052, 3318246279, 3416684106, 3985972956, 2359399778, 2874082439, 3822001804, 3523255869, 3667386335, 2233443271, 3541758807, 2197788012, 2991944802, 3630222692);
+            TestUtils.AreEqual(~a0, r0);
+
+            uint4x4 a1 = uint4x4(1289372466, 1951018596, 1545651937, 717936457, 1284504687, 1342785385, 869629475, 2045854321, 1282546942, 1562433528, 1824824810, 1736570715, 508906058, 2060752880, 1867418756, 388530274);
+            uint4x4 r1 = uint4x4(3005594829, 2343948699, 2749315358, 3577030838, 3010462608, 2952181910, 3425337820, 2249112974, 3012420353, 2732533767, 2470142485, 2558396580, 3786061237, 2234214415, 2427548539, 3906437021);
+            TestUtils.AreEqual(~a1, r1);
+
+            uint4x4 a2 = uint4x4(695179852, 897923626, 1816190464, 1362906829, 1227946838, 700158434, 189609278, 956441808, 2123488810, 1593014251, 19223061, 1722107954, 1636875694, 1914097392, 1382545027, 1285277010);
+            uint4x4 r2 = uint4x4(3599787443, 3397043669, 2478776831, 2932060466, 3067020457, 3594808861, 4105358017, 3338525487, 2171478485, 2701953044, 4275744234, 2572859341, 2658091601, 2380869903, 2912422268, 3009690285);
+            TestUtils.AreEqual(~a2, r2);
+
+            uint4x4 a3 = uint4x4(722020848, 183545104, 2006881282, 685422512, 70717710, 1636059183, 1218560768, 1078350342, 1743219894, 894044458, 110742707, 1831797788, 2111543080, 858442193, 907645851, 1672993750);
+            uint4x4 r3 = uint4x4(3572946447, 4111422191, 2288086013, 3609544783, 4224249585, 2658908112, 3076406527, 3216616953, 2551747401, 3400922837, 4184224588, 2463169507, 2183424215, 3436525102, 3387321444, 2621973545);
+            TestUtils.AreEqual(~a3, r3);
+        }
+
+
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..8c8d1fae04d301c4a27a307bead0d37653dd0eb2
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUint4x4.gen.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9c652e046dd97fc4aadae764262652ad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs
new file mode 100644
index 0000000000000000000000000000000000000000..addf5dbbba284bb164a05265ea19219f66bb69b3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs
@@ -0,0 +1,707 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics.Tests
+{
+    class TestUtils
+    {
+        
+        public static void AreEqual(bool a, bool b)
+        {
+            Assert.AreEqual(a, b);
+        }
+
+        public static void AreEqual(int a, int b)
+        {
+            Assert.AreEqual(a, b);
+        }
+
+        public static void AreEqual(uint a, uint b)
+        {
+            Assert.AreEqual(a, b);
+        }
+
+        public static void AreEqual(long a, long b)
+        {
+            Assert.AreEqual(a, b);
+        }
+
+        public static void AreEqual(ulong a, ulong b)
+        {
+            Assert.AreEqual(a, b);
+        }
+
+        public static void AreEqual(float a, float b, float delta = 0.0f)
+        {
+            Assert.AreEqual(a, b, delta);
+        }
+
+        public static void AreEqual(float a, float b, int maxUlp, bool signedZeroEqual)
+        {
+            if (signedZeroEqual && a == b)
+                return;
+
+            if(isfinite(a) && isfinite(b))
+            {
+                int ia = asint(a);
+                int ib = asint(b);
+                if ((ia ^ ib) < 0)
+                    Assert.AreEqual(true, false);
+                int ulps = abs(ia - ib);
+                Assert.AreEqual(true, ulps <= maxUlp);
+            }
+            else
+            {
+                if (a != b && (!isnan(a) || !isnan(b)))
+                    Assert.AreEqual(true, false);
+            }
+        }
+
+        public static void AreEqual(double a, double b, double delta = 0.0)
+        {
+            Assert.AreEqual(a, b, delta);
+        }
+
+        public static void AreEqual(double a, double b, int maxUlp, bool signedZeroEqual)
+        {
+            if (signedZeroEqual && a == b)
+                return;
+
+            if (isfinite(a) && isfinite(b))
+            {
+                long la = aslong(a);
+                long lb = aslong(b);
+                if ((la ^ lb) < 0)
+                    Assert.AreEqual(true, false);
+                long ulps = abs(la - lb);
+                Assert.AreEqual(true, ulps <= maxUlp);
+            }
+            else
+            {
+                if (a != b && (!isnan(a) || !isnan(b)))
+                    Assert.AreEqual(true, false);
+            }
+        }
+
+
+        // bool
+        public static void AreEqual(bool2 a, bool2 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+        }
+
+        public static void AreEqual(bool3 a, bool3 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+        }
+
+        public static void AreEqual(bool4 a, bool4 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+            AreEqual(a.w, b.w);
+        }
+
+
+        public static void AreEqual(bool2x2 a, bool2x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(bool3x2 a, bool3x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(bool4x2 a, bool4x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+
+        public static void AreEqual(bool2x3 a, bool2x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(bool3x3 a, bool3x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(bool4x3 a, bool4x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+
+        public static void AreEqual(bool2x4 a, bool2x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(bool3x4 a, bool3x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(bool4x4 a, bool4x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        // int
+        public static void AreEqual(int2 a, int2 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+        }
+
+        public static void AreEqual(int3 a, int3 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+        }
+
+        public static void AreEqual(int4 a, int4 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+            AreEqual(a.w, b.w);
+        }
+
+
+        public static void AreEqual(int2x2 a, int2x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(int3x2 a, int3x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(int4x2 a, int4x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+
+        public static void AreEqual(int2x3 a, int2x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(int3x3 a, int3x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(int4x3 a, int4x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+
+
+        public static void AreEqual(int2x4 a, int2x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(int3x4 a, int3x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(int4x4 a, int4x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+
+        // uint
+        public static void AreEqual(uint2 a, uint2 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+        }
+
+        public static void AreEqual(uint3 a, uint3 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+        }
+
+        public static void AreEqual(uint4 a, uint4 b)
+        {
+            AreEqual(a.x, b.x);
+            AreEqual(a.y, b.y);
+            AreEqual(a.z, b.z);
+            AreEqual(a.w, b.w);
+        }
+
+
+        public static void AreEqual(uint2x2 a, uint2x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(uint3x2 a, uint3x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+        public static void AreEqual(uint4x2 a, uint4x2 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+        }
+
+
+        public static void AreEqual(uint2x3 a, uint2x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(uint3x3 a, uint3x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+        public static void AreEqual(uint4x3 a, uint4x3 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+        }
+
+
+        public static void AreEqual(uint2x4 a, uint2x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(uint3x4 a, uint3x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        public static void AreEqual(uint4x4 a, uint4x4 b)
+        {
+            AreEqual(a.c0, b.c0);
+            AreEqual(a.c1, b.c1);
+            AreEqual(a.c2, b.c2);
+            AreEqual(a.c3, b.c3);
+        }
+
+        // float
+        public static void AreEqual(float2 a, float2 b, float delta = 0.0f)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+        }
+
+        public static void AreEqual(float2 a, float2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float3 a, float3 b, float delta = 0.0f)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+            AreEqual(a.z, b.z, delta);
+        }
+
+        public static void AreEqual(float3 a, float3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+            AreEqual(a.z, b.z, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float4 a, float4 b, float delta = 0.0f)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+            AreEqual(a.z, b.z, delta);
+            AreEqual(a.w, b.w, delta);
+        }
+
+        public static void AreEqual(float4 a, float4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+            AreEqual(a.z, b.z, maxUlp, signedZeroEqual);
+            AreEqual(a.w, b.w, maxUlp, signedZeroEqual);
+        }
+
+
+        public static void AreEqual(float2x2 a, float2x2 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(float2x2 a, float2x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float3x2 a, float3x2 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(float3x2 a, float3x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float4x2 a, float4x2 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(float4x2 a, float4x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+
+        public static void AreEqual(float2x3 a, float2x3 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(float2x3 a, float2x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float3x3 a, float3x3 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(float3x3 a, float3x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float4x3 a, float4x3 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(float4x3 a, float4x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+
+        public static void AreEqual(float2x4 a, float2x4 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(float2x4 a, float2x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float3x4 a, float3x4 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(float3x4 a, float3x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(float4x4 a, float4x4 b, float delta = 0.0f)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(float4x4 a, float4x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        // double
+        public static void AreEqual(double2 a, double2 b, double delta = 0.0)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+        }
+
+        public static void AreEqual(double2 a, double2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double3 a, double3 b, double delta = 0.0)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+            AreEqual(a.z, b.z, delta);
+        }
+
+        public static void AreEqual(double3 a, double3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+            AreEqual(a.z, b.z, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double4 a, double4 b, double delta = 0.0)
+        {
+            AreEqual(a.x, b.x, delta);
+            AreEqual(a.y, b.y, delta);
+            AreEqual(a.z, b.z, delta);
+            AreEqual(a.w, b.w, delta);
+        }
+
+        public static void AreEqual(double4 a, double4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.x, b.x, maxUlp, signedZeroEqual);
+            AreEqual(a.y, b.y, maxUlp, signedZeroEqual);
+            AreEqual(a.z, b.z, maxUlp, signedZeroEqual);
+            AreEqual(a.w, b.w, maxUlp, signedZeroEqual);
+        }
+
+
+        public static void AreEqual(double2x2 a, double2x2 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(double2x2 a, double2x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double3x2 a, double3x2 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(double3x2 a, double3x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double4x2 a, double4x2 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+        }
+
+        public static void AreEqual(double4x2 a, double4x2 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double2x3 a, double2x3 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(double2x3 a, double2x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double3x3 a, double3x3 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(double3x3 a, double3x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double4x3 a, double4x3 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+        }
+
+        public static void AreEqual(double4x3 a, double4x3 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+        }
+
+
+        public static void AreEqual(double2x4 a, double2x4 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(double2x4 a, double2x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double3x4 a, double3x4 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(double3x4 a, double3x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(double4x4 a, double4x4 b, double delta = 0.0)
+        {
+            AreEqual(a.c0, b.c0, delta);
+            AreEqual(a.c1, b.c1, delta);
+            AreEqual(a.c2, b.c2, delta);
+            AreEqual(a.c3, b.c3, delta);
+        }
+
+        public static void AreEqual(double4x4 a, double4x4 b, int maxUlp, bool signedZeroEqual)
+        {
+            AreEqual(a.c0, b.c0, maxUlp, signedZeroEqual);
+            AreEqual(a.c1, b.c1, maxUlp, signedZeroEqual);
+            AreEqual(a.c2, b.c2, maxUlp, signedZeroEqual);
+            AreEqual(a.c3, b.c3, maxUlp, signedZeroEqual);
+        }
+
+        public static void AreEqual(quaternion a, quaternion b, float delta = 0.0f)
+        {
+            AreEqual(a.value, b.value, delta);
+        }
+
+        public static void AreEqual(RigidTransform a, RigidTransform b, float delta = 0.0f)
+        {
+            AreEqual(a.rot, b.rot, delta);
+            AreEqual(a.pos, b.pos, delta);
+        }
+    }
+}
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs.meta
new file mode 100644
index 0000000000000000000000000000000000000000..5629e131e6a1a39b5b8f67b2105fcc227b9cc499
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/Shared/TestUtils.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cff1594319560b44ba925eb76a273c80
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: